commit d821e25fdb0e97e3405595cf2e0f7d3f94ac5b1d
Author: Olivier Guinart <olivier_guinart+github@live.com>
Date:   Fri Dec 30 16:46:52 2016 -0800

    First commit

diff --git a/Coloring/Classification/ClassificationFormat.cs b/Coloring/Classification/ClassificationFormat.cs
new file mode 100644
index 0000000..2810d6e
--- /dev/null
+++ b/Coloring/Classification/ClassificationFormat.cs
@@ -0,0 +1,84 @@
+using System.ComponentModel.Composition;
+using System.Windows.Media;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Utilities;
+//using Microsoft.VisualStudio.Language.StandardClassification;
+
+namespace VSMerlin32.Coloring.Classification
+{
+    #region Format definition
+
+    [Export(typeof(EditorFormatDefinition))]
+    [ClassificationType(ClassificationTypeNames = Merlin32TokenHelper.Merlin32Comment)]
+    [Name("Merlin32CommentFormat")]
+    [UserVisible(false)]
+    [Order(Before = Priority.Default)]
+    internal sealed class CommentFormat : ClassificationFormatDefinition
+    {
+        public CommentFormat()
+        {
+            this.DisplayName = "This is a comment"; //human readable version of the name
+            this.ForegroundColor = Colors.Green;
+        }
+    }
+
+    [Export(typeof(EditorFormatDefinition))]
+    [ClassificationType(ClassificationTypeNames = Merlin32TokenHelper.Merlin32Opcode)]
+    [Name("Merlin32OpcodeFormat")]
+    [UserVisible(false)]
+    [Order(Before = Priority.Default)]
+    internal sealed class OpcodeFormat : ClassificationFormatDefinition
+    {
+        public OpcodeFormat()
+        {
+            this.DisplayName = "This is an opcode"; //human readable version of the name
+            this.ForegroundColor = Colors.Blue;
+            // this.IsBold = true;
+        }
+    }
+
+    [Export(typeof(EditorFormatDefinition))]
+    [ClassificationType(ClassificationTypeNames = Merlin32TokenHelper.Merlin32Directive)]
+    [Name("Merlin32DirectiveFormat")]
+    [UserVisible(false)]
+    [Order(Before = Priority.Default)]
+    internal sealed class DirectiveFormat : ClassificationFormatDefinition
+    {
+        public DirectiveFormat()
+        {
+            this.DisplayName = "This is an directive"; //human readable version of the name
+            this.ForegroundColor = Colors.DarkCyan;
+            // this.IsBold = true;
+        }
+    }
+
+    [Export(typeof(EditorFormatDefinition))]
+    [ClassificationType(ClassificationTypeNames = Merlin32TokenHelper.Merlin32DataDefine)]
+    [Name("Merlin32DataDefineFormat")]
+    [UserVisible(false)]
+    [Order(Before = Priority.Default)]
+    internal sealed class DataDefineFormat : ClassificationFormatDefinition
+    {
+        public DataDefineFormat()
+        {
+            this.DisplayName = "This is data definition"; //human readable version of the name
+            this.ForegroundColor = Colors.DarkOrchid;
+            // this.IsBold = true;
+        }
+    }
+
+    [Export(typeof(EditorFormatDefinition))]
+    [ClassificationType(ClassificationTypeNames = Merlin32TokenHelper.Merlin32Text)]
+    [Name("Merlin32TextFormat")]
+    [UserVisible(false)]
+    [Order(Before = Priority.Default)]
+    internal sealed class TextFormat : ClassificationFormatDefinition
+    {
+        public TextFormat()
+        {
+            this.DisplayName = "This is a text"; //human readable version of the name
+            this.ForegroundColor = Colors.DarkRed;
+        }
+    }
+    #endregion //Format definition
+}
diff --git a/Coloring/Classification/ClassificationType.cs b/Coloring/Classification/ClassificationType.cs
new file mode 100644
index 0000000..aa99655
--- /dev/null
+++ b/Coloring/Classification/ClassificationType.cs
@@ -0,0 +1,48 @@
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Utilities;
+
+namespace VSMerlin32.Coloring.Classification
+{
+    internal static class OrdinaryClassificationDefinition
+    {
+        #region Type definition
+
+        /// <summary>
+        /// Defines the "opcode" classification type.
+        /// </summary>
+        [Export(typeof(ClassificationTypeDefinition))]
+        [Name(Merlin32TokenHelper.Merlin32Opcode)]
+        internal static ClassificationTypeDefinition opcode = null;
+
+        /// <summary>
+        /// Defines the "directive" classification type.
+        /// </summary>
+        [Export(typeof(ClassificationTypeDefinition))]
+        [Name(Merlin32TokenHelper.Merlin32Directive)]
+        internal static ClassificationTypeDefinition directive = null;
+
+        /// <summary>
+        /// Defines the "datadefine" classification type.
+        /// </summary>
+        [Export(typeof(ClassificationTypeDefinition))]
+        [Name(Merlin32TokenHelper.Merlin32DataDefine)]
+        internal static ClassificationTypeDefinition datadefine = null;
+
+        /// <summary>
+        /// Defines the "text" classification type.
+        /// </summary>
+        [Export(typeof(ClassificationTypeDefinition))]
+        [Name(Merlin32TokenHelper.Merlin32Text)]
+        internal static ClassificationTypeDefinition text = null;
+
+        /// <summary>
+        /// Defines the "comment" classification type.
+        /// </summary>
+        [Export(typeof(ClassificationTypeDefinition))]
+        [Name(Merlin32TokenHelper.Merlin32Comment)]
+        internal static ClassificationTypeDefinition comment = null;
+        
+        #endregion
+    }
+}
diff --git a/Coloring/Classification/Merlin32sClassifier.cs b/Coloring/Classification/Merlin32sClassifier.cs
new file mode 100644
index 0000000..332dbeb
--- /dev/null
+++ b/Coloring/Classification/Merlin32sClassifier.cs
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Utilities;
+
+namespace VSMerlin32.Coloring.Classification
+{
+    [Export(typeof(ITaggerProvider))]
+    [ContentType("Merlin32")]
+    [TagType(typeof(ClassificationTag))]
+    internal sealed class Merlin32ClassifierProvider : ITaggerProvider
+    {
+
+        [Export]
+        [Name("Merlin32")]
+        [BaseDefinition("code")]
+        internal static ContentTypeDefinition Merlin32ContentType = null;
+
+        [Export]
+        [FileExtension(".s")]
+        [ContentType("Merlin32")]
+        internal static FileExtensionToContentTypeDefinition Merlin32FileType = null;
+
+        [Import]
+        internal IClassificationTypeRegistryService ClassificationTypeRegistry = null;
+
+        [Import]
+        internal IBufferTagAggregatorFactoryService aggregatorFactory = null;
+
+        public ITagger<T> CreateTagger<T>(ITextBuffer buffer) where T : ITag
+        {
+
+            ITagAggregator<Merlin32TokenTag> Merlin32TagAggregator =
+                                            aggregatorFactory.CreateTagAggregator<Merlin32TokenTag>(buffer);
+
+            return new Merlin32Classifier(buffer, Merlin32TagAggregator, ClassificationTypeRegistry) as ITagger<T>;
+        }
+    }
+
+    internal sealed class Merlin32Classifier : ITagger<ClassificationTag>
+    {
+        ITextBuffer _buffer;
+        ITagAggregator<Merlin32TokenTag> _aggregator;
+        IDictionary<Merlin32TokenTypes, IClassificationType> _Merlin32Types;
+
+        internal Merlin32Classifier(ITextBuffer buffer,
+                               ITagAggregator<Merlin32TokenTag> Merlin32TagAggregator,
+                               IClassificationTypeRegistryService typeService)
+        {
+            _buffer = buffer;
+            _aggregator = Merlin32TagAggregator;
+            _Merlin32Types = new Dictionary<Merlin32TokenTypes, IClassificationType>();
+
+            foreach (Merlin32TokenTypes token in Enum.GetValues(typeof(Merlin32TokenTypes)))
+                _Merlin32Types[token] = typeService.GetClassificationType(token.ToString());
+        }
+
+        public event EventHandler<SnapshotSpanEventArgs> TagsChanged
+        {
+            add { }
+            remove { }
+        }
+
+        public IEnumerable<ITagSpan<ClassificationTag>> GetTags(NormalizedSnapshotSpanCollection spans)
+        {
+
+            foreach (var tagSpan in this._aggregator.GetTags(spans))
+            {
+                var tagSpans = tagSpan.Span.GetSpans(spans[0].Snapshot);
+                yield return 
+                    new TagSpan<ClassificationTag>(tagSpans[0], 
+                        new ClassificationTag(_Merlin32Types[tagSpan.Tag.Tokentype]));
+            }
+        }
+    }
+}
diff --git a/Coloring/Data/SnapshotHelper.cs b/Coloring/Data/SnapshotHelper.cs
new file mode 100644
index 0000000..e5057a3
--- /dev/null
+++ b/Coloring/Data/SnapshotHelper.cs
@@ -0,0 +1,16 @@
+using Microsoft.VisualStudio.Text;
+
+namespace VSMerlin32.Coloring.Data
+{
+	internal class SnapshotHelper
+	{
+		public SnapshotSpan Snapshot { get; private set; }
+		public Merlin32TokenTypes TokenType { get; private set; }
+
+		public SnapshotHelper(SnapshotSpan span, Merlin32TokenTypes type)
+		{
+			Snapshot = span;
+			TokenType = type;
+		}
+	}
+}
diff --git a/Coloring/Merlin32CodeHelper.cs b/Coloring/Merlin32CodeHelper.cs
new file mode 100644
index 0000000..dbc095f
--- /dev/null
+++ b/Coloring/Merlin32CodeHelper.cs
@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using Microsoft.VisualStudio.Text;
+using VSMerlin32.Coloring.Data;
+
+namespace VSMerlin32.Coloring
+{
+    internal class Merlin32CodeHelper
+    {
+        const string COMMENT_REG = @"((\u003B)|(\u002A))(.*)"; // ;
+        //const string KEYLINE_REG = @"\u0023([\w]*)"; // #
+        //const string HEAD_REG = @"^(\w)+(.*)\u003a\u002d"; // :-
+        const string TEXT_REG = @"(""|')[^']*(""|')";
+        //const string PUBLIC_REG = @"^\u003a\u002d+(.)*";
+        // const string OPCODE_REG = @"(org)|(ldy)";
+        // OPCODE_REG is initialized dynamically below.
+        static string OPCODE_REG = "";
+        //const string TEXT2_REG = @"\$[^']*\$";
+        static string DIRECTIVE_REG = "";
+        static string DATADEFINE_REG = "";
+        
+        public static IEnumerable<SnapshotHelper> GetTokens(SnapshotSpan span)
+        {
+            string strTempRegex; // temp var string
+            ITextSnapshotLine containingLine = span.Start.GetContainingLine();
+            int curLoc = containingLine.Start.Position;
+            string formattedLine = containingLine.GetText();
+
+            int commentMatch = int.MaxValue;
+            Regex reg = new Regex(COMMENT_REG);
+            foreach (Match match in reg.Matches(formattedLine))
+            {
+                commentMatch = match.Index < commentMatch ? match.Index : commentMatch;
+                yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Comment);
+            }
+
+            /*
+            reg = new Regex(KEYLINE_REG);
+            foreach (Match match in reg.Matches(formattedLine))
+            {
+                if (match.Index < commentMatch)
+                    yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Keyline);
+            }
+
+            reg = new Regex(HEAD_REG);
+            foreach (Match match in reg.Matches(formattedLine))
+            {
+                if (match.Index < commentMatch)
+                {
+                    int length = formattedLine.IndexOf("(");
+                    yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), length != -1 ? length : match.Length), Merlin32TokenTypes.Merlin32Keyline);
+                }
+            }
+            */
+
+            reg = new Regex(TEXT_REG);
+            foreach (Match match in reg.Matches(formattedLine))
+            {
+                if (match.Index < commentMatch)
+                    yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Text);
+            }
+
+            // OG NEW
+            // OPCODES
+            strTempRegex = "";
+            foreach (Merlin32Opcodes token in Enum.GetValues(typeof(Merlin32Opcodes)))
+            {
+                strTempRegex += (token.ToString() + ("|"));
+            }
+            // we remove the last "|" added
+            strTempRegex = strTempRegex.Remove(strTempRegex.LastIndexOf("|"));
+            OPCODE_REG = string.Format(@"\b({0})\b", strTempRegex);
+
+            reg = new Regex(OPCODE_REG,RegexOptions.IgnoreCase);
+            foreach (Match match in reg.Matches(formattedLine))
+            {
+                if (match.Index < commentMatch)
+                    yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Opcode);
+            }
+
+            // OG NEW
+            // DIRECTIVES
+            strTempRegex = "";
+            foreach (Merlin32Directives token in Enum.GetValues(typeof(Merlin32Directives)))
+            {
+                if (token.ToString() != Resources.directives.ELUP)
+                    strTempRegex += (token.ToString() + ("|"));
+            }
+            // we remove the last "|" added
+            // strTempRegex = strTempRegex.Remove(strTempRegex.LastIndexOf("|"));
+            // DIRECTIVE_REG = string.Format(@"\b({0})\b", strTempRegex);
+            DIRECTIVE_REG = string.Format(@"\b({0})\b|{1}", strTempRegex, Resources.directives.ELUPRegex);
+
+            reg = new Regex(DIRECTIVE_REG, RegexOptions.IgnoreCase);
+            foreach (Match match in reg.Matches(formattedLine))
+            {
+                if (match.Index < commentMatch)
+                    yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Directive);
+            }
+
+            // OG NEW
+            // DATADEFINES
+            strTempRegex = "";
+            foreach (Merlin32DataDefines token in Enum.GetValues(typeof(Merlin32DataDefines)))
+            {
+                strTempRegex += (token.ToString() + ("|"));
+            }
+            // we remove the last "|" added
+            strTempRegex = strTempRegex.Remove(strTempRegex.LastIndexOf("|"));
+            DATADEFINE_REG = string.Format(@"\b({0})\b", strTempRegex);
+
+            reg = new Regex(DATADEFINE_REG, RegexOptions.IgnoreCase);
+            foreach (Match match in reg.Matches(formattedLine))
+            {
+                if (match.Index < commentMatch)
+                    yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32DataDefine);
+            }
+
+            /*
+            reg = new Regex(PUBLIC_REG);
+            foreach (Match match in reg.Matches(formattedLine))
+            {
+                if (match.Index < commentMatch)
+                    yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Publictoken);
+            }
+            */
+        }
+    }
+}
diff --git a/Coloring/Merlin32TokenTag.cs b/Coloring/Merlin32TokenTag.cs
new file mode 100644
index 0000000..d225c1c
--- /dev/null
+++ b/Coloring/Merlin32TokenTag.cs
@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft Corporation
+// All rights reserved
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Utilities;
+using VSMerlin32.Coloring.Data;
+
+namespace VSMerlin32.Coloring
+{
+
+    [Export(typeof(ITaggerProvider))]
+    [ContentType("Merlin32")]
+    [TagType(typeof(Merlin32TokenTag))]
+    internal sealed class Merlin32TokenTagProvider : ITaggerProvider
+    {
+
+        public ITagger<T> CreateTagger<T>(ITextBuffer buffer) where T : ITag
+        {
+            return new Merlin32TokenTagger(buffer) as ITagger<T>;
+        }
+    }
+
+    public class Merlin32TokenTag : ITag 
+    {
+        public Merlin32TokenTypes Tokentype { get; private set; }
+
+        public Merlin32TokenTag(Merlin32TokenTypes type)
+        {
+            this.Tokentype = type;
+        }
+    }
+
+    internal sealed class Merlin32TokenTagger : ITagger<Merlin32TokenTag>
+    {
+
+        ITextBuffer _buffer;
+        IDictionary<string, Merlin32TokenTypes> _Merlin32Types;
+
+        internal Merlin32TokenTagger(ITextBuffer buffer)
+        {
+            _buffer = buffer;
+            _Merlin32Types = new Dictionary<string, Merlin32TokenTypes>();
+
+            foreach (Merlin32TokenTypes token in Enum.GetValues(typeof(Merlin32TokenTypes)))
+                _Merlin32Types.Add(token.ToString(), token);
+        }
+
+        public event EventHandler<SnapshotSpanEventArgs> TagsChanged
+        {
+            add { }
+            remove { }
+        }
+
+        // OG !!!
+        public IEnumerable<ITagSpan<Merlin32TokenTag>> GetTags(NormalizedSnapshotSpanCollection spans)
+        {
+            foreach (SnapshotSpan curSpan in spans)
+            {
+                ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
+                int curLoc = containingLine.Start.Position;
+                
+                string formattedLine = containingLine.GetText();
+
+                foreach (SnapshotHelper item in Merlin32CodeHelper.GetTokens(curSpan))
+                {
+                    if (item.Snapshot.IntersectsWith(curSpan))
+                        yield return new TagSpan<Merlin32TokenTag>(item.Snapshot, 
+                            new Merlin32TokenTag(item.TokenType));
+                }
+
+                //add an extra char location because of the space
+                curLoc += formattedLine.Length + 1;
+            }
+        }
+    }
+}
diff --git a/Coloring/Merlin32TokenTypes.cs b/Coloring/Merlin32TokenTypes.cs
new file mode 100644
index 0000000..f41693b
--- /dev/null
+++ b/Coloring/Merlin32TokenTypes.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Resources;
+using System.Reflection;
+using System.Collections;
+
+namespace VSMerlin32
+{
+    public enum Merlin32Opcodes
+    {
+        ADC, ADCL, AND, ANDL, ASL, 
+        BCC, BLT, BCS, BGE, BEQ, BIT, BMI, BNE, BPL, BRA, BRK, BRL, BVC, BVS, 
+        CLC, CLD, CLI, CLV, CMP, CMPL, COP, CPX, CPY, 
+        DEC, DEX, DEY, 
+        EOR, EORL, 
+        INC, INX, INY, 
+        JMP, JML, JMPL, JSR, JSL, 
+        LDA, LDAL, LDX, LDY, LSR, 
+        MVN, MVP, 
+        NOP, 
+        ORA, ORAL, 
+        PEA, PEI, PER, PHA, PHB, PHD, PHK, PHP, PHX, PHY, PLA, PLB, PLD, PLP, PLX, PLY, 
+        REP, ROL, ROR, RTI, RTL, RTS, 
+        SBC, SBCL, SEC, SED, SEI, SEP, STA, STAL, STP, STX, STY, STZ, 
+        TAX, TAY, TCD, TCS, TDC, TRB, TSB, TSC, TSX, TXA, TXS, TXY, TYA, TYX, 
+        WAI, WDM, 
+        XBA, XCE
+    }
+
+    public enum Merlin32Directives
+    {
+        EQU,
+        ANOP, ORG, PUT, PUTBIN,          /* PUTBIN n'existe pas dans Merlin 16+ */
+        START, END, 
+        DUM, DEND, 
+        MX, XC, LONGA, LONGI, 
+        USE, USING, 
+        REL, DSK, LNK, SAV, 
+        TYP, 
+        IF, DO, ELSE, FIN, 
+        LUP, ELUP, // --^, ignored for now (invalid enum)
+        ERR, DAT, 
+        AST, CYC, EXP, LST, LSTDO, PAG, TTL, SKP, TR, KBD, PAU, SW, USR
+    }
+
+    public enum Merlin32DataDefines
+    {
+        DA, DW, DDB, DFB, DB, ADR, ADRL, HEX, DS, 
+        DC, DE,   /* ? */
+        ASC, DCI, INV, FLS, REV, STR, STRL, 
+        CHK 
+    }
+
+    class Merlin32KeywordsHelper
+    {
+        /* The regex for opcodes is now defined in Merlin32CodeHelper.cs
+        public const string strMerlin32OpcodesRegex =
+@"\b(ADC(L?)|AND(L?)|ASL|BCC|BCS|BEQ|BIT|BMI|BNE|BPL|BRA|BRK|BRL|BVC|BVS|CLC|CLD|CLI|CLV|CMP(L?)|COP|CPX|CPY|DEC|DEX|DEY|EOR(L?)|INC|INX|INY|JMP(L?)|JML|JSR|JSL|LDA(L?)|LDX|LDY|LSR|MVN|MVP|NOP|ORA(L?)|ORG|PEA|PEI|PER|PHA|PHB|PHD|PHK|PHP|PHX|PHY|PLA|PLB|PLD|PLP|PLX|PLY|REP|ROL|ROR|RTI|RTL|RTS|SBC(L?)|SEC|SED|SEI|SEP|STA(L?)|STP|STX|STY|STZ|TAX|TAY|TCD|TCS|TDC|TRB|TSB|TSC|TSX|TXA|TXS|TXY|TYA|TYX|WAI|WDM|XBA|XCE)\b";
+        */
+
+        public IDictionary<string, string> _Merlin32KeywordsQuickInfo;
+
+        public Merlin32KeywordsHelper()
+        {
+            // Read the resources for opcodes, all of them...
+            ResourceSet rsOpcodes = VSMerlin32.Resources.opcodes.ResourceManager.GetResourceSet(System.Globalization.CultureInfo.CurrentCulture, true, true);
+            // Read the resources for directives too, all of them...
+            ResourceSet rsDirectives = VSMerlin32.Resources.directives.ResourceManager.GetResourceSet(System.Globalization.CultureInfo.CurrentCulture, true, true);
+            // Read the resources for datadefines too, all of them...
+            ResourceSet rsData = VSMerlin32.Resources.data.ResourceManager.GetResourceSet(System.Globalization.CultureInfo.CurrentCulture, true, true);
+
+            _Merlin32KeywordsQuickInfo = new Dictionary<string, string>();
+            foreach (Merlin32Opcodes token in Enum.GetValues(typeof(Merlin32Opcodes)))
+            {
+                // _Merlin32OpcodesQuickInfo[token.ToString()] = token.ToString();
+                _Merlin32KeywordsQuickInfo[token.ToString()] = rsOpcodes.GetString(token.ToString());
+            }
+            foreach (Merlin32Directives token in Enum.GetValues(typeof(Merlin32Directives)))
+            {
+                _Merlin32KeywordsQuickInfo[token.ToString()] = rsDirectives.GetString(token.ToString());
+            }
+            foreach (Merlin32DataDefines token in Enum.GetValues(typeof(Merlin32DataDefines)))
+            {
+                _Merlin32KeywordsQuickInfo[token.ToString()] = rsData.GetString(token.ToString());
+            }   
+            /*
+            _Merlin32OpcodesQuickInfo[Merlin32Opcodes.ORG.ToString()] = VSMerlin32.strings.ORG;
+            */
+        }
+    }
+
+    internal sealed class Merlin32TokenHelper
+    {
+        public const string Merlin32Opcode = "Merlin32Opcode";
+        public const string Merlin32Directive = "Merlin32Directive";
+        public const string Merlin32DataDefine = "Merlin32DataDefine";
+        public const string Merlin32Text = "Merlin32Text";
+        public const string Merlin32Comment = "Merlin32Comment";
+    }
+
+    public enum Merlin32TokenTypes
+    {
+        Merlin32Opcode, Merlin32Directive, Merlin32DataDefine, Merlin32Text, Merlin32Comment
+    }
+}
diff --git a/Intellisense/CompletionController.cs b/Intellisense/CompletionController.cs
new file mode 100644
index 0000000..7539b47
--- /dev/null
+++ b/Intellisense/CompletionController.cs
@@ -0,0 +1,176 @@
+using System;
+using System.ComponentModel.Composition;
+using System.Runtime.InteropServices;
+using Microsoft.VisualStudio;
+using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.OLE.Interop;
+
+using Microsoft.VisualStudio.Shell;
+
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.TextManager.Interop;
+using Microsoft.VisualStudio.Utilities;
+
+using Microsoft.VisualStudio.Text.Operations;
+
+
+namespace VSMerlin32
+{
+    #region Command Filter
+
+    [Export(typeof(IVsTextViewCreationListener))]
+    [Name("Merlin32CompletionController")]
+    [ContentType("Merlin32")]
+    [TextViewRole(PredefinedTextViewRoles.Editable)]
+    internal sealed class VsTextViewCreationListener : IVsTextViewCreationListener
+    {
+        [Import]
+        internal IVsEditorAdaptersFactoryService AdaptersFactory = null;
+        [Import]
+        internal ICompletionBroker CompletionBroker { get; set; }
+        [Import]
+        internal SVsServiceProvider ServiceProvider { get; set; }
+
+        public void VsTextViewCreated(IVsTextView textViewAdapter)
+        {
+            ITextView textView = AdaptersFactory.GetWpfTextView(textViewAdapter);
+            if (textView == null)
+                return;
+
+            Func<CommandFilter> createCommandHandler = delegate() { return new CommandFilter(textViewAdapter, textView, this); };
+            textView.Properties.GetOrCreateSingletonProperty(createCommandHandler);
+        }
+    }
+
+    internal sealed class CommandFilter : IOleCommandTarget
+    {
+        private IOleCommandTarget m_nextCommandHandler;
+        private ITextView m_textView;
+        private VsTextViewCreationListener m_provider;
+        private ICompletionSession m_session;
+
+        internal CommandFilter(IVsTextView textViewAdapter, ITextView textView, VsTextViewCreationListener provider)
+        {
+            this.m_textView = textView;
+            this.m_provider = provider;
+
+            //add the command to the command chain
+            textViewAdapter.AddCommandFilter(this, out m_nextCommandHandler);
+        }
+
+        public int QueryStatus(ref Guid pguidCmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText)
+        {
+            return m_nextCommandHandler.QueryStatus(ref pguidCmdGroup, cCmds, prgCmds, pCmdText);
+        }
+
+        public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
+        {
+            if (VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider))
+            {
+                return m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
+            }
+            //make a copy of this so we can look at it after forwarding some commands 
+            uint commandID = nCmdID;
+            char typedChar = char.MinValue;
+            //make sure the input is a char before getting it 
+            if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)
+            {
+                typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn);
+            }
+
+            //check for a commit character 
+            if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN
+                || nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB
+                || char.IsWhiteSpace(typedChar) 
+                || char.IsPunctuation(typedChar))
+            {
+                //check for a a selection 
+                if (m_session != null && !m_session.IsDismissed)
+                {
+                    //if the selection is fully selected, commit the current session 
+                    if (m_session.SelectedCompletionSet.SelectionStatus.IsSelected)
+                    {
+                        m_session.Commit();
+                        //also, don't add the character to the buffer 
+                        return VSConstants.S_OK;
+                    }
+                    else
+                    {
+                        //if there is no selection, dismiss the session
+                        m_session.Dismiss();
+                    }
+                }
+            }
+
+            //pass along the command so the char is added to the buffer 
+            int retVal = m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
+            bool handled = false;
+            if (!typedChar.Equals(char.MinValue) && ((char.IsLetterOrDigit(typedChar)) || ((typedChar == '\'') || (typedChar == '"'))))
+            {
+                if (m_session == null || m_session.IsDismissed) // If there is no active session, bring up completion
+                {
+                    this.TriggerCompletion();
+                    // No need to filter for single and double-quotes, the choice IS the characted, just doubled, and already populated in a single completionset if we're here...
+                    if ((typedChar == '\'') || (typedChar == '"'))
+                    {
+                        // We need to save the currect caret position because we'll position it in between the single/double quotes after the commit...
+                        ITextCaret CaretBeforeCommit = m_session.TextView.Caret;
+                        m_session.Commit();
+                        this.m_textView.Caret.MoveTo(CaretBeforeCommit.Position.BufferPosition - 1);
+                    }
+                    else
+                    {
+                        m_session.Filter();
+                    }
+                }
+                else     //the completion session is already active, so just filter
+                {
+                    m_session.Filter();
+                }
+                handled = true;
+            }
+            else if (commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE   //redo the filter if there is a deletion
+                || commandID == (uint)VSConstants.VSStd2KCmdID.DELETE)
+            {
+                if (m_session != null && !m_session.IsDismissed)
+                    m_session.Filter();
+                handled = true;
+            }
+
+            if (handled) return VSConstants.S_OK;
+            return retVal;
+        }
+
+        private bool TriggerCompletion()
+        {
+            //the caret must be in a non-projection location 
+            SnapshotPoint? caretPoint =
+            m_textView.Caret.Position.Point.GetPoint(
+            textBuffer => (!textBuffer.ContentType.IsOfType("projection")), PositionAffinity.Predecessor);
+            if (!caretPoint.HasValue)
+            {
+                return false;
+            }
+
+            m_session = m_provider.CompletionBroker.CreateCompletionSession(m_textView,
+                caretPoint.Value.Snapshot.CreateTrackingPoint(caretPoint.Value.Position, PointTrackingMode.Positive),
+                true);
+
+            //subscribe to the Dismissed event on the session 
+            m_session.Dismissed += this.OnSessionDismissed;
+            m_session.Start();
+
+            return true;
+        }
+
+        private void OnSessionDismissed(object sender, EventArgs e)
+        {
+            m_session.Dismissed -= this.OnSessionDismissed;
+            m_session = null;
+        }
+    }
+
+    #endregion
+}
\ No newline at end of file
diff --git a/Intellisense/CompletionSource.cs b/Intellisense/CompletionSource.cs
new file mode 100644
index 0000000..52380a5
--- /dev/null
+++ b/Intellisense/CompletionSource.cs
@@ -0,0 +1,148 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Operations;
+using Microsoft.VisualStudio.Utilities;
+
+namespace VSMerlin32
+{
+    [Export(typeof(ICompletionSourceProvider))]
+    [ContentType("Merlin32")]
+    [Name("Merlin32Completion")]
+    internal class Merlin32CompletionSourceProvider : ICompletionSourceProvider
+    {
+        [Import]
+        internal ITextStructureNavigatorSelectorService NavigatorService { get; set; }
+
+        public ICompletionSource TryCreateCompletionSource(ITextBuffer textBuffer)
+        {
+            return new Merlin32CompletionSource(this, textBuffer);
+        }
+    }
+
+    internal class Merlin32CompletionSource : ICompletionSource
+    {
+        private Merlin32CompletionSourceProvider m_sourceprovider;
+        private ITextBuffer m_buffer;
+        private List<Completion> m_compList;
+        private bool m_isDisposed = false;
+
+        public Merlin32CompletionSource(Merlin32CompletionSourceProvider sourceprovider, ITextBuffer buffer)
+        {
+            m_sourceprovider = sourceprovider;
+            m_buffer = buffer;
+        }
+
+        public void AugmentCompletionSession(ICompletionSession session, IList<CompletionSet> completionSets)
+        {
+            if (m_isDisposed)
+                throw new ObjectDisposedException("Merlin32CompletionSource");
+
+            List<string> strList = new List<string>();
+            char chTyped = ((session.TextView.Caret.Position.BufferPosition) - 1).GetChar();
+            // Testing for single and double quotes because these will be autocompleted...
+            if ((chTyped == '\'') || (chTyped == '"'))
+            {
+                strList.Add(chTyped.ToString() + chTyped.ToString());
+            }
+            else
+            {
+                // If the user has been typing lowercase, we'll present a lowercase list of keywords/opcodes...
+                if (char.IsLower(chTyped))
+                {
+                    foreach (Merlin32Opcodes token in Enum.GetValues(typeof(Merlin32Opcodes)))
+                    {
+                        strList.Add(token.ToString().ToLower());
+                    }
+                    foreach (Merlin32Directives token in Enum.GetValues(typeof(Merlin32Directives)))
+                    {
+                        if (token.ToString().ToLower() == Merlin32Directives.ELUP.ToString().ToLower())
+                        {
+                            strList.Add(Resources.directives.ELUPValue);
+                        }
+                        else
+                        {
+                            strList.Add(token.ToString().ToLower());
+                        }
+                    }
+                    foreach (Merlin32DataDefines token in Enum.GetValues(typeof(Merlin32DataDefines)))
+                    {
+                        strList.Add(token.ToString().ToLower());
+                    }
+                }
+                else
+                {
+                    foreach (Merlin32Opcodes token in Enum.GetValues(typeof(Merlin32Opcodes)))
+                    {
+                        strList.Add(token.ToString());
+                    }
+                    foreach (Merlin32Directives token in Enum.GetValues(typeof(Merlin32Directives)))
+                    {
+                        if (token.ToString() == Merlin32Directives.ELUP.ToString())
+                        {
+                            strList.Add(Resources.directives.ELUPValue);
+                        }
+                        else
+                        {
+                            strList.Add(token.ToString());
+                        }
+                    }
+                    foreach (Merlin32DataDefines token in Enum.GetValues(typeof(Merlin32DataDefines)))
+                    {
+                        strList.Add(token.ToString());
+                    }
+                }
+
+                // OG We also need to replace "ELUP" with "--^"
+                // OG 2015/10/21
+                strList.Sort();
+                // strList[strList.IndexOf(Merlin32Directives.ELUP.ToString())] = "--^";
+                // OG
+            }
+            m_compList = new List<Completion>();
+            foreach (string str in strList)
+                m_compList.Add(new Completion(str, str, str, null, null));
+            /*
+            ITextSnapshot snapshot = _buffer.CurrentSnapshot;
+            var triggerPoint = (SnapshotPoint)session.GetTriggerPoint(snapshot);
+
+            if (triggerPoint == null)
+                return;
+
+            var line = triggerPoint.GetContainingLine();
+            SnapshotPoint start = triggerPoint;
+
+            while (start > line.Start && !char.IsWhiteSpace((start - 1).GetChar()))
+            {
+                start -= 1;
+            }
+
+            var applicableTo = snapshot.CreateTrackingSpan(new SnapshotSpan(start, triggerPoint), SpanTrackingMode.EdgeInclusive);
+            */
+
+            completionSets.Add(new CompletionSet("All", "All", FindTokenSpanAtPosition(session.GetTriggerPoint(m_buffer), session), m_compList, null));
+        }
+
+        private ITrackingSpan FindTokenSpanAtPosition(ITrackingPoint point, ICompletionSession session)
+        {
+            SnapshotPoint currentPoint = (session.TextView.Caret.Position.BufferPosition) - 1;
+            ITextStructureNavigator navigator = m_sourceprovider.NavigatorService.GetTextStructureNavigator(m_buffer);
+            TextExtent extent = navigator.GetExtentOfWord(currentPoint);
+            return currentPoint.Snapshot.CreateTrackingSpan(extent.Span, SpanTrackingMode.EdgeInclusive);
+        }
+
+        public void Dispose()
+        {
+            if (!m_isDisposed)
+            {
+                GC.SuppressFinalize(this);
+                m_isDisposed = true;
+            }
+        }
+    }
+}
+
diff --git a/Intellisense/Merlin32QuickInfoSource.cs b/Intellisense/Merlin32QuickInfoSource.cs
new file mode 100644
index 0000000..cfc18ed
--- /dev/null
+++ b/Intellisense/Merlin32QuickInfoSource.cs
@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.VisualStudio.Language.Intellisense;
+using System.Collections.ObjectModel;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Tagging;
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Utilities;
+using VSMerlin32.Coloring;
+
+namespace VSMerlin32
+{
+    
+    [Export(typeof(IQuickInfoSourceProvider))]
+    [ContentType("Merlin32")]
+    [Name("Merlin32QuickInfo")]
+    class Merlin32QuickInfoSourceProvider : IQuickInfoSourceProvider
+    {
+
+        [Import]
+        IBufferTagAggregatorFactoryService aggService = null;
+
+        public IQuickInfoSource TryCreateQuickInfoSource(ITextBuffer textBuffer)
+        {
+            return new Merlin32QuickInfoSource(textBuffer, aggService.CreateTagAggregator<Merlin32TokenTag>(textBuffer));
+        }
+    }
+
+    class Merlin32QuickInfoSource : IQuickInfoSource
+    {
+        private ITagAggregator<Merlin32TokenTag> _aggregator;
+        private ITextBuffer _buffer;
+        private Merlin32KeywordsHelper _Merlin32OpcodesHelper = new Merlin32KeywordsHelper();
+        private bool _disposed = false;
+
+
+        public Merlin32QuickInfoSource(ITextBuffer buffer, ITagAggregator<Merlin32TokenTag> aggregator)
+        {
+            _aggregator = aggregator;
+            _buffer = buffer;
+        }
+
+        public void AugmentQuickInfoSession(IQuickInfoSession session, IList<object> quickInfoContent, out ITrackingSpan applicableToSpan)
+        {
+            applicableToSpan = null;
+
+            if (_disposed)
+                throw new ObjectDisposedException("TestQuickInfoSource");
+
+            var triggerPoint = (SnapshotPoint) session.GetTriggerPoint(_buffer.CurrentSnapshot);
+
+            if (triggerPoint == null)
+                return;
+
+            foreach (IMappingTagSpan<Merlin32TokenTag> curTag in _aggregator.GetTags(new SnapshotSpan(triggerPoint, triggerPoint)))
+            {
+                if ((curTag.Tag.Tokentype == Merlin32TokenTypes.Merlin32Opcode) || (curTag.Tag.Tokentype == Merlin32TokenTypes.Merlin32Directive) || (curTag.Tag.Tokentype == Merlin32TokenTypes.Merlin32DataDefine))
+                {
+                    var tagSpan = curTag.Span.GetSpans(_buffer).First();
+                    // Before
+                    //if (tagSpan.GetText() == Merlin32Opcodes.ORG.ToString())
+                    //{
+                    //    applicableToSpan = _buffer.CurrentSnapshot.CreateTrackingSpan(tagSpan, SpanTrackingMode.EdgeExclusive);
+                    //    quickInfoContent.Add("Must be followed by the program's origin, e.g. org $800");
+                    //}
+                    // OG After
+                    applicableToSpan = _buffer.CurrentSnapshot.CreateTrackingSpan(tagSpan, SpanTrackingMode.EdgeExclusive);
+                    if (tagSpan.GetText() == Resources.directives.ELUPValue)
+                    {
+                        quickInfoContent.Add(_Merlin32OpcodesHelper._Merlin32KeywordsQuickInfo[Merlin32Directives.ELUP.ToString()]);
+                    }
+                    else
+                    {
+                        // TODO: why do I get an exception here if I don't test for string.Empty!? 
+                        /*
+                         System.Collections.Generic.KeyNotFoundException was unhandled by user code
+                          HResult=-2146232969
+                          Message=The given key was not present in the dictionary.
+                          Source=mscorlib
+                          StackTrace:
+                               at System.Collections.Generic.Dictionary`2.get_Item(TKey key)
+                               at VSMerlin32.Merlin32QuickInfoSource.AugmentQuickInfoSession(IQuickInfoSession session, IList`1 quickInfoContent, ITrackingSpan& applicableToSpan) in c:\Users\Olivier\Documents\Visual Studio 2013\Projects\Merlin32 Language Service\Merlin32Language\Intellisense\Merlin32QuickInfoSource.cs:line 77
+                               at Microsoft.VisualStudio.Language.Intellisense.Implementation.QuickInfoSession.Recalculate()
+                               at Microsoft.VisualStudio.Language.Intellisense.Implementation.QuickInfoSession.Start()
+                               at Microsoft.VisualStudio.Language.Intellisense.Implementation.DefaultQuickInfoController.OnTextView_MouseHover(Object sender, MouseHoverEventArgs e)
+                               at Microsoft.VisualStudio.Text.Editor.Implementation.WpfTextView.RaiseHoverEvents()
+                          InnerException: 
+                         */
+                        // Compare with changeset 151, you'll see why I ask...
+                        if (string.Empty != tagSpan.GetText())
+                        {
+                            quickInfoContent.Add(_Merlin32OpcodesHelper._Merlin32KeywordsQuickInfo[tagSpan.GetText().ToUpper()]);
+                        }
+                    }
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            _disposed = true;
+        }
+    }
+}
+
diff --git a/Intellisense/QuickInfoController.cs b/Intellisense/QuickInfoController.cs
new file mode 100644
index 0000000..35aa42b
--- /dev/null
+++ b/Intellisense/QuickInfoController.cs
@@ -0,0 +1,105 @@
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+using System;
+using System.Collections.Generic;
+using System.Windows.Input;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+
+namespace VSLTK.Intellisense
+{
+    #region IIntellisenseController
+
+    internal class TemplateQuickInfoController : IIntellisenseController
+    {
+        #region Private Data Members
+
+        private ITextView _textView;
+        private IList<ITextBuffer> _subjectBuffers;
+        private TemplateQuickInfoControllerProvider _componentContext;
+
+        private IQuickInfoSession _session;
+
+        #endregion
+
+        #region Constructors
+
+        internal TemplateQuickInfoController(ITextView textView, IList<ITextBuffer> subjectBuffers, TemplateQuickInfoControllerProvider componentContext)
+        {
+            _textView = textView;
+            _subjectBuffers = subjectBuffers;
+            _componentContext = componentContext;
+
+            _textView.MouseHover += this.OnTextViewMouseHover;
+        }
+
+        #endregion
+
+        #region IIntellisenseController Members
+
+        public void ConnectSubjectBuffer(ITextBuffer subjectBuffer)
+        {
+        }
+
+        public void DisconnectSubjectBuffer(ITextBuffer subjectBuffer)
+        {
+        }
+
+        public void Detach(ITextView textView)
+        {
+            if (_textView == textView)
+            {
+                _textView.MouseHover -= this.OnTextViewMouseHover;
+                _textView = null;
+            }
+        }
+
+        #endregion
+
+        #region Event Handlers
+
+        private void OnTextViewMouseHover(object sender, MouseHoverEventArgs e)
+        {
+            SnapshotPoint? point = this.GetMousePosition(new SnapshotPoint(_textView.TextSnapshot, e.Position));
+
+            if (point != null)
+            {
+                ITrackingPoint triggerPoint = point.Value.Snapshot.CreateTrackingPoint(point.Value.Position,
+                    PointTrackingMode.Positive);
+
+                // Find the broker for this buffer
+
+                if (!_componentContext.QuickInfoBroker.IsQuickInfoActive(_textView))
+                {
+                    _session = _componentContext.QuickInfoBroker.CreateQuickInfoSession(_textView, triggerPoint, true);
+                    _session.Start();
+                }
+            }
+        }
+
+        #endregion
+
+        #region Private Implementation
+
+        private SnapshotPoint? GetMousePosition(SnapshotPoint topPosition)
+        {
+            // Map this point down to the appropriate subject buffer.
+
+            return _textView.BufferGraph.MapDownToFirstMatch
+                (
+                topPosition,
+                PointTrackingMode.Positive,
+                snapshot => _subjectBuffers.Contains(snapshot.TextBuffer),
+                PositionAffinity.Predecessor
+                );
+        }
+
+        #endregion
+    }
+
+    #endregion
+}
\ No newline at end of file
diff --git a/Intellisense/QuickInfoControllerProvider.cs b/Intellisense/QuickInfoControllerProvider.cs
new file mode 100644
index 0000000..73081e0
--- /dev/null
+++ b/Intellisense/QuickInfoControllerProvider.cs
@@ -0,0 +1,41 @@
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+
+namespace VSLTK.Intellisense
+{
+    #region IIntellisenseControllerProvider
+
+    [Export(typeof(IIntellisenseControllerProvider))]
+    [Name("Template QuickInfo Controller")]
+    [ContentType("text")]
+    internal class TemplateQuickInfoControllerProvider : IIntellisenseControllerProvider
+    {
+        #region Asset Imports
+
+        [Import]
+        internal IQuickInfoBroker QuickInfoBroker { get; set; }
+
+        #endregion
+
+        #region IIntellisenseControllerFactory Members
+
+        public IIntellisenseController TryCreateIntellisenseController(ITextView textView,
+            IList<ITextBuffer> subjectBuffers)
+        {
+            return new TemplateQuickInfoController(textView, subjectBuffers, this);
+        }
+
+        #endregion
+
+    }
+
+    #endregion
+}
\ No newline at end of file
diff --git a/License.txt b/License.txt
new file mode 100644
index 0000000..c5d10c5
--- /dev/null
+++ b/License.txt
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 OlivierGuinart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Merlin32Language.csproj b/Merlin32Language.csproj
new file mode 100644
index 0000000..1f21300
--- /dev/null
+++ b/Merlin32Language.csproj
@@ -0,0 +1,210 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+    <SccProjectName>SAK</SccProjectName>
+    <SccLocalPath>SAK</SccLocalPath>
+    <SccAuxPath>SAK</SccAuxPath>
+    <SccProvider>SAK</SccProvider>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <OldToolsVersion>4.0</OldToolsVersion>
+    <TargetFrameworkProfile />
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>false</SignAssembly>
+  </PropertyGroup>
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>10.0.20305</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectTypeGuids>{82b43b9b-a64c-4715-b499-d71e9ca2bd60};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <ProjectGuid>{F091221E-FD10-41A7-AAC4-C9359178BDB1}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>VSMerlin32</RootNamespace>
+    <AssemblyName>Merlin32Language</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <GeneratePkgDefFile>false</GeneratePkgDefFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <StartAction>Program</StartAction>
+    <StartProgram>$(ProgramFiles)\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe</StartProgram>
+    <StartArguments>/rootsuffix Exp</StartArguments>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <StartAction>Program</StartAction>
+    <StartProgram>$(ProgramFiles)\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe</StartProgram>
+    <StartArguments>/rootsuffix Exp</StartArguments>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.VisualStudio.CoreUtility">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.Editor">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.Language.Intellisense">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.OLE.Interop">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.Shell.Interop" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Interop.8.0" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Interop.9.0" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Interop.10.0" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Interop.11.0" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Interop.12.0">
+      <EmbedInteropTypes>true</EmbedInteropTypes>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.Shell.12.0" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Immutable.10.0" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Immutable.11.0" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Immutable.12.0" />
+    <Reference Include="Microsoft.VisualStudio.Text.Data">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.Text.Logic">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.Text.UI">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.Text.UI.Wpf">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.TextManager.Interop, Version=7.1.40304.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+    <Reference Include="PresentationCore" />
+    <Reference Include="PresentationFramework" />
+    <Reference Include="System" />
+    <Reference Include="System.ComponentModel.Composition" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+    <Reference Include="System.Xaml" />
+    <Reference Include="WindowsBase" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Coloring\Classification\ClassificationFormat.cs" />
+    <Compile Include="Coloring\Classification\ClassificationType.cs" />
+    <Compile Include="Coloring\Data\SnapshotHelper.cs" />
+    <Compile Include="Resources\data.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>data.resx</DependentUpon>
+    </Compile>
+    <Compile Include="Resources\directives.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>directives.resx</DependentUpon>
+    </Compile>
+    <Compile Include="Intellisense\CompletionController.cs" />
+    <Compile Include="Intellisense\CompletionSource.cs" />
+    <Compile Include="Intellisense\Merlin32QuickInfoSource.cs" />
+    <Compile Include="Coloring\Merlin32CodeHelper.cs" />
+    <Compile Include="Coloring\Merlin32TokenTypes.cs" />
+    <Compile Include="Coloring\Merlin32TokenTag.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Coloring\Classification\Merlin32sClassifier.cs" />
+    <Compile Include="Intellisense\QuickInfoController.cs" />
+    <Compile Include="Intellisense\QuickInfoControllerProvider.cs" />
+    <Compile Include="Resources\opcodes.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>opcodes.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="source.extension.vsixmanifest">
+      <SubType>Designer</SubType>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="License.txt">
+      <IncludeInVSIX>true</IncludeInVSIX>
+    </Content>
+    <Content Include="Test\HelloWorld.s" />
+    <Content Include="VSLanguageServiceIcon.jpg">
+      <IncludeInVSIX>true</IncludeInVSIX>
+    </Content>
+    <Content Include="VSLanguageServicePreviewImage.jpg">
+      <IncludeInVSIX>true</IncludeInVSIX>
+    </Content>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Resources\data.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>data.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Resources\directives.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>directives.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Resources\opcodes.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>opcodes.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include=".NETFramework,Version=v4.5">
+      <Visible>False</Visible>
+      <ProductName>Microsoft .NET Framework 4.5 %28x86 and x64%29</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Import Project="$(VSToolsPath)\VSSDK\Microsoft.VsSDK.targets" Condition="'$(VSToolsPath)' != ''" />
+  <PropertyGroup>
+    <PreBuildEvent>
+    </PreBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
diff --git a/Merlin32Language.sln b/Merlin32Language.sln
new file mode 100644
index 0000000..3d53302
--- /dev/null
+++ b/Merlin32Language.sln
@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.24720.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Merlin32Language", "Merlin32Language.csproj", "{F091221E-FD10-41A7-AAC4-C9359178BDB1}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F091221E-FD10-41A7-AAC4-C9359178BDB1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F091221E-FD10-41A7-AAC4-C9359178BDB1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F091221E-FD10-41A7-AAC4-C9359178BDB1}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{F091221E-FD10-41A7-AAC4-C9359178BDB1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F091221E-FD10-41A7-AAC4-C9359178BDB1}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(TeamFoundationVersionControl) = preSolution
+		SccNumberOfProjects = 2
+		SccEnterpriseProvider = {4CA58AB2-18FA-4F8D-95D4-32DDF27D184C}
+		SccTeamFoundationServer = https://aito.visualstudio.com/
+		SccLocalPath0 = .
+		SccProjectUniqueName1 = Merlin32Language.csproj
+		SccLocalPath1 = .
+	EndGlobalSection
+EndGlobal
diff --git a/Merlin32LanguageService.gif b/Merlin32LanguageService.gif
new file mode 100644
index 0000000..5966779
Binary files /dev/null and b/Merlin32LanguageService.gif differ
diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..07b2c64
--- /dev/null
+++ b/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("VSMerlin32")]
+[assembly: AssemblyDescription("Merlin32 classifier extension to the Visual Studio Editor")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("VSMerlin32")]
+[assembly: AssemblyCopyright("Copyright © Olivier Guinart")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..75c478e
--- /dev/null
+++ b/README.md
@@ -0,0 +1,17 @@
+# Merlin32 Visual Studio Language Service
+Visual Studio language service for 6502 Merlin32 cross-assembler (http://brutaldeluxe.fr/products/crossdevtools/merlin/index.html).
+
+
+Provides the ability to develop 6502 assembly programs within a modern IDE.
+
+Features:
+
+* Syntax coloring
+* Statement completion
+* Opcodes tooltip 
+
+![](https://github.com/OlivierGuinart/Merlin32Language/blob/master/Merlin32LanguageService.gif)
+
+Visual Studio extension available in the Visual Studio gallery: https://marketplace.visualstudio.com/vsgallery/4f84ade5-b04b-451f-92fc-272c06f31359
+
+
diff --git a/Resources/data.Designer.cs b/Resources/data.Designer.cs
new file mode 100644
index 0000000..8b580cd
--- /dev/null
+++ b/Resources/data.Designer.cs
@@ -0,0 +1,234 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace VSMerlin32.Resources {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class data {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal data() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("VSMerlin32.Resources.data", typeof(data).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define ADdRess (3 bytes).
+        /// </summary>
+        internal static string ADR {
+            get {
+                return ResourceManager.GetString("ADR", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define ADdRess Long (4 bytes).
+        /// </summary>
+        internal static string ADRL {
+            get {
+                return ResourceManager.GetString("ADRL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define ASCii (&quot;&quot; positive, &apos;&apos; negative).
+        /// </summary>
+        internal static string ASC {
+            get {
+                return ResourceManager.GetString("ASC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Place a CHecKsum in object code.
+        /// </summary>
+        internal static string CHK {
+            get {
+                return ResourceManager.GetString("CHK", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define Address (2 bytes).
+        /// </summary>
+        internal static string DA {
+            get {
+                return ResourceManager.GetString("DA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define Byte (1 byte).
+        /// </summary>
+        internal static string DB {
+            get {
+                return ResourceManager.GetString("DB", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ???.
+        /// </summary>
+        internal static string DC {
+            get {
+                return ResourceManager.GetString("DC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define Dextral Character Inverted.
+        /// </summary>
+        internal static string DCI {
+            get {
+                return ResourceManager.GetString("DCI", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define Double Byte (2 bytes).
+        /// </summary>
+        internal static string DDB {
+            get {
+                return ResourceManager.GetString("DDB", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ???.
+        /// </summary>
+        internal static string DE {
+            get {
+                return ResourceManager.GetString("DE", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to DeFine Byte (1 byte).
+        /// </summary>
+        internal static string DFB {
+            get {
+                return ResourceManager.GetString("DFB", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define Storage (x bytes) (e.g. DS 10 (put $00 in 10 bytes), DS 10,$80 (put $80 in 10 bytes)).
+        /// </summary>
+        internal static string DS {
+            get {
+                return ResourceManager.GetString("DS", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define Word (2 bytes).
+        /// </summary>
+        internal static string DW {
+            get {
+                return ResourceManager.GetString("DW", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define FLaShing text.
+        /// </summary>
+        internal static string FLS {
+            get {
+                return ResourceManager.GetString("FLS", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define HEX data (1 byte).
+        /// </summary>
+        internal static string HEX {
+            get {
+                return ResourceManager.GetString("HEX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define INVerse text.
+        /// </summary>
+        internal static string INV {
+            get {
+                return ResourceManager.GetString("INV", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define REVerse.
+        /// </summary>
+        internal static string REV {
+            get {
+                return ResourceManager.GetString("REV", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define STRing with leading length (1 byte).
+        /// </summary>
+        internal static string STR {
+            get {
+                return ResourceManager.GetString("STR", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define STRing Long with leading length (2 bytes).
+        /// </summary>
+        internal static string STRL {
+            get {
+                return ResourceManager.GetString("STRL", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/Resources/data.resx b/Resources/data.resx
new file mode 100644
index 0000000..61a26f9
--- /dev/null
+++ b/Resources/data.resx
@@ -0,0 +1,177 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ADR" xml:space="preserve">
+    <value>Define ADdRess (3 bytes)</value>
+  </data>
+  <data name="ADRL" xml:space="preserve">
+    <value>Define ADdRess Long (4 bytes)</value>
+  </data>
+  <data name="ASC" xml:space="preserve">
+    <value>Define ASCii ("" positive, '' negative)</value>
+  </data>
+  <data name="CHK" xml:space="preserve">
+    <value>Place a CHecKsum in object code</value>
+  </data>
+  <data name="DA" xml:space="preserve">
+    <value>Define Address (2 bytes)</value>
+  </data>
+  <data name="DB" xml:space="preserve">
+    <value>Define Byte (1 byte)</value>
+  </data>
+  <data name="DC" xml:space="preserve">
+    <value>???</value>
+  </data>
+  <data name="DCI" xml:space="preserve">
+    <value>Define Dextral Character Inverted</value>
+  </data>
+  <data name="DDB" xml:space="preserve">
+    <value>Define Double Byte (2 bytes)</value>
+  </data>
+  <data name="DE" xml:space="preserve">
+    <value>???</value>
+  </data>
+  <data name="DFB" xml:space="preserve">
+    <value>DeFine Byte (1 byte)</value>
+  </data>
+  <data name="DS" xml:space="preserve">
+    <value>Define Storage (x bytes) (e.g. DS 10 (put $00 in 10 bytes), DS 10,$80 (put $80 in 10 bytes))</value>
+  </data>
+  <data name="DW" xml:space="preserve">
+    <value>Define Word (2 bytes)</value>
+  </data>
+  <data name="FLS" xml:space="preserve">
+    <value>Define FLaShing text</value>
+  </data>
+  <data name="HEX" xml:space="preserve">
+    <value>Define HEX data (1 byte)</value>
+  </data>
+  <data name="INV" xml:space="preserve">
+    <value>Define INVerse text</value>
+  </data>
+  <data name="REV" xml:space="preserve">
+    <value>Define REVerse</value>
+  </data>
+  <data name="STR" xml:space="preserve">
+    <value>Define STRing with leading length (1 byte)</value>
+  </data>
+  <data name="STRL" xml:space="preserve">
+    <value>Define STRing Long with leading length (2 bytes)</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/Resources/directives.Designer.cs b/Resources/directives.Designer.cs
new file mode 100644
index 0000000..eff2724
--- /dev/null
+++ b/Resources/directives.Designer.cs
@@ -0,0 +1,450 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace VSMerlin32.Resources {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class directives {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal directives() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("VSMerlin32.Resources.directives", typeof(directives).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ???.
+        /// </summary>
+        internal static string ANOP {
+            get {
+                return ResourceManager.GetString("ANOP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Send a line of ASTerisks.
+        /// </summary>
+        internal static string AST {
+            get {
+                return ResourceManager.GetString("AST", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Calculate and print CYCle times for the code.
+        /// </summary>
+        internal static string CYC {
+            get {
+                return ResourceManager.GetString("CYC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to DATe stamp assembly listing.
+        /// </summary>
+        internal static string DAT {
+            get {
+                return ResourceManager.GetString("DAT", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Dummy section END.
+        /// </summary>
+        internal static string DEND {
+            get {
+                return ResourceManager.GetString("DEND", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to DO directive.
+        /// </summary>
+        internal static string DO {
+            get {
+                return ResourceManager.GetString("DO", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define the name of the output binary after the directive.
+        /// </summary>
+        internal static string DSK {
+            get {
+                return ResourceManager.GetString("DSK", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to DUMmy section start.
+        /// </summary>
+        internal static string DUM {
+            get {
+                return ResourceManager.GetString("DUM", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ELSE condition.
+        /// </summary>
+        internal static string ELSE {
+            get {
+                return ResourceManager.GetString("ELSE", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to End of LUP.
+        /// </summary>
+        internal static string ELUP {
+            get {
+                return ResourceManager.GetString("ELUP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to (--\^).
+        /// </summary>
+        internal static string ELUPRegex {
+            get {
+                return ResourceManager.GetString("ELUPRegex", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to --^.
+        /// </summary>
+        internal static string ELUPValue {
+            get {
+                return ResourceManager.GetString("ELUPValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to END of source file.
+        /// </summary>
+        internal static string END {
+            get {
+                return ResourceManager.GetString("END", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define constant values (same as =).
+        /// </summary>
+        internal static string EQU {
+            get {
+                return ResourceManager.GetString("EQU", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Force ERRor.
+        /// </summary>
+        internal static string ERR {
+            get {
+                return ResourceManager.GetString("ERR", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Macro EXPand control.
+        /// </summary>
+        internal static string EXP {
+            get {
+                return ResourceManager.GetString("EXP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Mandatory ENDdirective for IF and DO .
+        /// </summary>
+        internal static string FIN {
+            get {
+                return ResourceManager.GetString("FIN", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to IF condition.
+        /// </summary>
+        internal static string IF {
+            get {
+                return ResourceManager.GetString("IF", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define label from KeyBoarD.
+        /// </summary>
+        internal static string KBD {
+            get {
+                return ResourceManager.GetString("KBD", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Relocate code (same as DSK in Merlin 32).
+        /// </summary>
+        internal static string LNK {
+            get {
+                return ResourceManager.GetString("LNK", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ???.
+        /// </summary>
+        internal static string LONGA {
+            get {
+                return ResourceManager.GetString("LONGA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ???.
+        /// </summary>
+        internal static string LONGI {
+            get {
+                return ResourceManager.GetString("LONGI", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to LiSTing control.
+        /// </summary>
+        internal static string LST {
+            get {
+                return ResourceManager.GetString("LST", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to LiSTDO OFF areas of code.
+        /// </summary>
+        internal static string LSTDO {
+            get {
+                return ResourceManager.GetString("LSTDO", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Repeat portions of the code (until the --^ directive).
+        /// </summary>
+        internal static string LUP {
+            get {
+                return ResourceManager.GetString("LUP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Set the size for M (Accumulator) and X (X and Y Registers).
+        /// </summary>
+        internal static string MX {
+            get {
+                return ResourceManager.GetString("MX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Must be followed by the program&apos;s origin, e.g. org $800.
+        /// </summary>
+        internal static string ORG {
+            get {
+                return ResourceManager.GetString("ORG", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to New PAGe.
+        /// </summary>
+        internal static string PAG {
+            get {
+                return ResourceManager.GetString("PAG", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to PAUse.
+        /// </summary>
+        internal static string PAU {
+            get {
+                return ResourceManager.GetString("PAU", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Insert the content of a source  file.
+        /// </summary>
+        internal static string PUT {
+            get {
+                return ResourceManager.GetString("PUT", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ???.
+        /// </summary>
+        internal static string PUTBIN {
+            get {
+                return ResourceManager.GetString("PUTBIN", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Use at the start of the program to write 16 bit relocatable code.
+        /// </summary>
+        internal static string REL {
+            get {
+                return ResourceManager.GetString("REL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Define the name of the output binary before the directive.
+        /// </summary>
+        internal static string SAV {
+            get {
+                return ResourceManager.GetString("SAV", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SKiP lines.
+        /// </summary>
+        internal static string SKP {
+            get {
+                return ResourceManager.GetString("SKP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ???.
+        /// </summary>
+        internal static string START {
+            get {
+                return ResourceManager.GetString("START", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SWeet16 opcodes.
+        /// </summary>
+        internal static string SW {
+            get {
+                return ResourceManager.GetString("SW", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to TRuncate control.
+        /// </summary>
+        internal static string TR {
+            get {
+                return ResourceManager.GetString("TR", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to TiTLe heading.
+        /// </summary>
+        internal static string TTL {
+            get {
+                return ResourceManager.GetString("TTL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Set the output file type (one byte: $00-$FF).
+        /// </summary>
+        internal static string TYP {
+            get {
+                return ResourceManager.GetString("TYP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Insert macros.
+        /// </summary>
+        internal static string USE {
+            get {
+                return ResourceManager.GetString("USE", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ???.
+        /// </summary>
+        internal static string USING {
+            get {
+                return ResourceManager.GetString("USING", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ???.
+        /// </summary>
+        internal static string USR {
+            get {
+                return ResourceManager.GetString("USR", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ???.
+        /// </summary>
+        internal static string XC {
+            get {
+                return ResourceManager.GetString("XC", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/Resources/directives.resx b/Resources/directives.resx
new file mode 100644
index 0000000..07d9f1f
--- /dev/null
+++ b/Resources/directives.resx
@@ -0,0 +1,249 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ANOP" xml:space="preserve">
+    <value>???</value>
+  </data>
+  <data name="AST" xml:space="preserve">
+    <value>Send a line of ASTerisks</value>
+  </data>
+  <data name="CYC" xml:space="preserve">
+    <value>Calculate and print CYCle times for the code</value>
+  </data>
+  <data name="DAT" xml:space="preserve">
+    <value>DATe stamp assembly listing</value>
+  </data>
+  <data name="DEND" xml:space="preserve">
+    <value>Dummy section END</value>
+  </data>
+  <data name="DO" xml:space="preserve">
+    <value>DO directive</value>
+  </data>
+  <data name="DSK" xml:space="preserve">
+    <value>Define the name of the output binary after the directive</value>
+  </data>
+  <data name="DUM" xml:space="preserve">
+    <value>DUMmy section start</value>
+  </data>
+  <data name="ELSE" xml:space="preserve">
+    <value>ELSE condition</value>
+  </data>
+  <data name="ELUP" xml:space="preserve">
+    <value>End of LUP</value>
+  </data>
+  <data name="ELUPRegex" xml:space="preserve">
+    <value>(--\^)</value>
+  </data>
+  <data name="ELUPValue" xml:space="preserve">
+    <value>--^</value>
+  </data>
+  <data name="END" xml:space="preserve">
+    <value>END of source file</value>
+  </data>
+  <data name="EQU" xml:space="preserve">
+    <value>Define constant values (same as =)</value>
+  </data>
+  <data name="ERR" xml:space="preserve">
+    <value>Force ERRor</value>
+  </data>
+  <data name="EXP" xml:space="preserve">
+    <value>Macro EXPand control</value>
+  </data>
+  <data name="FIN" xml:space="preserve">
+    <value>Mandatory ENDdirective for IF and DO </value>
+  </data>
+  <data name="IF" xml:space="preserve">
+    <value>IF condition</value>
+  </data>
+  <data name="KBD" xml:space="preserve">
+    <value>Define label from KeyBoarD</value>
+  </data>
+  <data name="LNK" xml:space="preserve">
+    <value>Relocate code (same as DSK in Merlin 32)</value>
+  </data>
+  <data name="LONGA" xml:space="preserve">
+    <value>???</value>
+  </data>
+  <data name="LONGI" xml:space="preserve">
+    <value>???</value>
+  </data>
+  <data name="LST" xml:space="preserve">
+    <value>LiSTing control</value>
+  </data>
+  <data name="LSTDO" xml:space="preserve">
+    <value>LiSTDO OFF areas of code</value>
+  </data>
+  <data name="LUP" xml:space="preserve">
+    <value>Repeat portions of the code (until the --^ directive)</value>
+  </data>
+  <data name="MX" xml:space="preserve">
+    <value>Set the size for M (Accumulator) and X (X and Y Registers)</value>
+  </data>
+  <data name="ORG" xml:space="preserve">
+    <value>Must be followed by the program's origin, e.g. org $800</value>
+  </data>
+  <data name="PAG" xml:space="preserve">
+    <value>New PAGe</value>
+  </data>
+  <data name="PAU" xml:space="preserve">
+    <value>PAUse</value>
+  </data>
+  <data name="PUT" xml:space="preserve">
+    <value>Insert the content of a source  file</value>
+  </data>
+  <data name="PUTBIN" xml:space="preserve">
+    <value>???</value>
+  </data>
+  <data name="REL" xml:space="preserve">
+    <value>Use at the start of the program to write 16 bit relocatable code</value>
+  </data>
+  <data name="SAV" xml:space="preserve">
+    <value>Define the name of the output binary before the directive</value>
+  </data>
+  <data name="SKP" xml:space="preserve">
+    <value>SKiP lines</value>
+  </data>
+  <data name="START" xml:space="preserve">
+    <value>???</value>
+  </data>
+  <data name="SW" xml:space="preserve">
+    <value>SWeet16 opcodes</value>
+  </data>
+  <data name="TR" xml:space="preserve">
+    <value>TRuncate control</value>
+  </data>
+  <data name="TTL" xml:space="preserve">
+    <value>TiTLe heading</value>
+  </data>
+  <data name="TYP" xml:space="preserve">
+    <value>Set the output file type (one byte: $00-$FF)</value>
+  </data>
+  <data name="USE" xml:space="preserve">
+    <value>Insert macros</value>
+  </data>
+  <data name="USING" xml:space="preserve">
+    <value>???</value>
+  </data>
+  <data name="USR" xml:space="preserve">
+    <value>???</value>
+  </data>
+  <data name="XC" xml:space="preserve">
+    <value>???</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/Resources/opcodes.Designer.cs b/Resources/opcodes.Designer.cs
new file mode 100644
index 0000000..b1bd9ea
--- /dev/null
+++ b/Resources/opcodes.Designer.cs
@@ -0,0 +1,972 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace VSMerlin32.Resources {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class opcodes {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal opcodes() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("VSMerlin32.Resources.opcodes", typeof(opcodes).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ADd with Carry.
+        /// </summary>
+        internal static string ADC {
+            get {
+                return ResourceManager.GetString("ADC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ADd with Carry Long.
+        /// </summary>
+        internal static string ADCL {
+            get {
+                return ResourceManager.GetString("ADCL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Bitwise AND with accumulator.
+        /// </summary>
+        internal static string AND {
+            get {
+                return ResourceManager.GetString("AND", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Bitwise AND with accumulator, Long.
+        /// </summary>
+        internal static string ANDL {
+            get {
+                return ResourceManager.GetString("ANDL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ASL shifts all bits left one position. 0 is shifted into bit 0 and the original bit 7 is shifted into the Carry.
+        /// </summary>
+        internal static string ASL {
+            get {
+                return ResourceManager.GetString("ASL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Branch if Carry Clear.
+        /// </summary>
+        internal static string BCC {
+            get {
+                return ResourceManager.GetString("BCC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Branch if Carry Set.
+        /// </summary>
+        internal static string BCS {
+            get {
+                return ResourceManager.GetString("BCS", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Branch if EQual/Branch if zero.
+        /// </summary>
+        internal static string BEQ {
+            get {
+                return ResourceManager.GetString("BEQ", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to BIt Test.
+        /// </summary>
+        internal static string BIT {
+            get {
+                return ResourceManager.GetString("BIT", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Branch if MInus value.
+        /// </summary>
+        internal static string BMI {
+            get {
+                return ResourceManager.GetString("BMI", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Branch if Not Equal/Branch if not zero.
+        /// </summary>
+        internal static string BNE {
+            get {
+                return ResourceManager.GetString("BNE", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Branch if PLus value.
+        /// </summary>
+        internal static string BPL {
+            get {
+                return ResourceManager.GetString("BPL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to BRanch Always.
+        /// </summary>
+        internal static string BRA {
+            get {
+                return ResourceManager.GetString("BRA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Software BReaK.
+        /// </summary>
+        internal static string BRK {
+            get {
+                return ResourceManager.GetString("BRK", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to BRanch always Long.
+        /// </summary>
+        internal static string BRL {
+            get {
+                return ResourceManager.GetString("BRL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Branch if oVerflow Clear.
+        /// </summary>
+        internal static string BVC {
+            get {
+                return ResourceManager.GetString("BVC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Branch if oVerflow Set.
+        /// </summary>
+        internal static string BVS {
+            get {
+                return ResourceManager.GetString("BVS", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to CLear Carry flag.
+        /// </summary>
+        internal static string CLC {
+            get {
+                return ResourceManager.GetString("CLC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to CLear Decimal flag.
+        /// </summary>
+        internal static string CLD {
+            get {
+                return ResourceManager.GetString("CLD", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to CLear Interrupt flag.
+        /// </summary>
+        internal static string CLI {
+            get {
+                return ResourceManager.GetString("CLI", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to CLear oVerflow flag.
+        /// </summary>
+        internal static string CLV {
+            get {
+                return ResourceManager.GetString("CLV", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to CoMPare accumulator with memory.
+        /// </summary>
+        internal static string CMP {
+            get {
+                return ResourceManager.GetString("CMP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to CoMPare accumulator with memory, Long.
+        /// </summary>
+        internal static string CMPL {
+            get {
+                return ResourceManager.GetString("CMPL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to COProcessor empowerment (interrupt).
+        /// </summary>
+        internal static string COP {
+            get {
+                return ResourceManager.GetString("COP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ComPare X with memory.
+        /// </summary>
+        internal static string CPX {
+            get {
+                return ResourceManager.GetString("CPX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ComPare Y with memory.
+        /// </summary>
+        internal static string CPY {
+            get {
+                return ResourceManager.GetString("CPY", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to DECrement accumulator or memory.
+        /// </summary>
+        internal static string DEC {
+            get {
+                return ResourceManager.GetString("DEC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to DEcrement X.
+        /// </summary>
+        internal static string DEX {
+            get {
+                return ResourceManager.GetString("DEX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Decrement Y.
+        /// </summary>
+        internal static string DEY {
+            get {
+                return ResourceManager.GetString("DEY", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Exclusive OR accumulator with memory.
+        /// </summary>
+        internal static string EOR {
+            get {
+                return ResourceManager.GetString("EOR", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Exclusive OR accumulator with memory, Long.
+        /// </summary>
+        internal static string EORL {
+            get {
+                return ResourceManager.GetString("EORL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to INCrement accumulator or memory.
+        /// </summary>
+        internal static string INC {
+            get {
+                return ResourceManager.GetString("INC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to INcrement X.
+        /// </summary>
+        internal static string INX {
+            get {
+                return ResourceManager.GetString("INX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to INcrement Y.
+        /// </summary>
+        internal static string INY {
+            get {
+                return ResourceManager.GetString("INY", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to JuMp, Long.
+        /// </summary>
+        internal static string JML {
+            get {
+                return ResourceManager.GetString("JML", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to JuMP.
+        /// </summary>
+        internal static string JMP {
+            get {
+                return ResourceManager.GetString("JMP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to JuMP, Long.
+        /// </summary>
+        internal static string JMPL {
+            get {
+                return ResourceManager.GetString("JMPL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Jump to Subroutine, Long.
+        /// </summary>
+        internal static string JSL {
+            get {
+                return ResourceManager.GetString("JSL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Jump to SubRoutine.
+        /// </summary>
+        internal static string JSR {
+            get {
+                return ResourceManager.GetString("JSR", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to LoaD Accumulator.
+        /// </summary>
+        internal static string LDA {
+            get {
+                return ResourceManager.GetString("LDA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to LoaD Accumulator, Long.
+        /// </summary>
+        internal static string LDAL {
+            get {
+                return ResourceManager.GetString("LDAL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to LoaD X register.
+        /// </summary>
+        internal static string LDX {
+            get {
+                return ResourceManager.GetString("LDX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to LoaD Y register.
+        /// </summary>
+        internal static string LDY {
+            get {
+                return ResourceManager.GetString("LDY", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to LSR shifts all bits right one position. 0 is shifted into bit 7 and the original bit 0 is shifted into the Carry.
+        /// </summary>
+        internal static string LSR {
+            get {
+                return ResourceManager.GetString("LSR", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Block MoVe Negative.
+        /// </summary>
+        internal static string MVN {
+            get {
+                return ResourceManager.GetString("MVN", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Block MoVe Positive.
+        /// </summary>
+        internal static string MVP {
+            get {
+                return ResourceManager.GetString("MVP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to No OPeration.
+        /// </summary>
+        internal static string NOP {
+            get {
+                return ResourceManager.GetString("NOP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Bitwise OR Accumulator with memory.
+        /// </summary>
+        internal static string ORA {
+            get {
+                return ResourceManager.GetString("ORA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Bitwise OR Accumulator with memory, Long.
+        /// </summary>
+        internal static string ORAL {
+            get {
+                return ResourceManager.GetString("ORAL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Push Effective Address.
+        /// </summary>
+        internal static string PEA {
+            get {
+                return ResourceManager.GetString("PEA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Push Effective Indirect address.
+        /// </summary>
+        internal static string PEI {
+            get {
+                return ResourceManager.GetString("PEI", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Push program countEr Relative.
+        /// </summary>
+        internal static string PER {
+            get {
+                return ResourceManager.GetString("PER", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to PusH Accumulator.
+        /// </summary>
+        internal static string PHA {
+            get {
+                return ResourceManager.GetString("PHA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to PusH data Bank register.
+        /// </summary>
+        internal static string PHB {
+            get {
+                return ResourceManager.GetString("PHB", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to PusH Direct page register.
+        /// </summary>
+        internal static string PHD {
+            get {
+                return ResourceManager.GetString("PHD", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to PusH program banK register.
+        /// </summary>
+        internal static string PHK {
+            get {
+                return ResourceManager.GetString("PHK", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to PusH Processor status flags.
+        /// </summary>
+        internal static string PHP {
+            get {
+                return ResourceManager.GetString("PHP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to PusH X.
+        /// </summary>
+        internal static string PHX {
+            get {
+                return ResourceManager.GetString("PHX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to PusH Y.
+        /// </summary>
+        internal static string PHY {
+            get {
+                return ResourceManager.GetString("PHY", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Pull Accumulator.
+        /// </summary>
+        internal static string PLA {
+            get {
+                return ResourceManager.GetString("PLA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Pull data Bank register.
+        /// </summary>
+        internal static string PLB {
+            get {
+                return ResourceManager.GetString("PLB", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Pull Direct page register.
+        /// </summary>
+        internal static string PLD {
+            get {
+                return ResourceManager.GetString("PLD", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Pull Processor status flags.
+        /// </summary>
+        internal static string PLP {
+            get {
+                return ResourceManager.GetString("PLP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Pull X.
+        /// </summary>
+        internal static string PLX {
+            get {
+                return ResourceManager.GetString("PLX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Pull Y.
+        /// </summary>
+        internal static string PLY {
+            get {
+                return ResourceManager.GetString("PLY", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to REset Processor status flag.
+        /// </summary>
+        internal static string REP {
+            get {
+                return ResourceManager.GetString("REP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ROtate Left accumulator or memory.
+        /// </summary>
+        internal static string ROL {
+            get {
+                return ResourceManager.GetString("ROL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ROtate Right accumulator or memory.
+        /// </summary>
+        internal static string ROR {
+            get {
+                return ResourceManager.GetString("ROR", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ReTurn from Interrupt.
+        /// </summary>
+        internal static string RTI {
+            get {
+                return ResourceManager.GetString("RTI", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ReTurn from subroutine, Long.
+        /// </summary>
+        internal static string RTL {
+            get {
+                return ResourceManager.GetString("RTL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ReTurn from Subroutine; pulls the top two bytes off the stack (low byte first) and transfers program control to that address+1.
+        /// </summary>
+        internal static string RTS {
+            get {
+                return ResourceManager.GetString("RTS", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SuBtract with Carry.
+        /// </summary>
+        internal static string SBC {
+            get {
+                return ResourceManager.GetString("SBC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SuBtract with Carry Long.
+        /// </summary>
+        internal static string SBCL {
+            get {
+                return ResourceManager.GetString("SBCL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SEt Carry flag.
+        /// </summary>
+        internal static string SEC {
+            get {
+                return ResourceManager.GetString("SEC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SEt Decimal flag.
+        /// </summary>
+        internal static string SED {
+            get {
+                return ResourceManager.GetString("SED", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SEt Interrupt flag.
+        /// </summary>
+        internal static string SEI {
+            get {
+                return ResourceManager.GetString("SEI", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SEt Processor status flag.
+        /// </summary>
+        internal static string SEP {
+            get {
+                return ResourceManager.GetString("SEP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to STore Accumulator to memory.
+        /// </summary>
+        internal static string STA {
+            get {
+                return ResourceManager.GetString("STA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to STore Accumulator to memory, Long.
+        /// </summary>
+        internal static string STAL {
+            get {
+                return ResourceManager.GetString("STAL", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SToP the clock.
+        /// </summary>
+        internal static string STP {
+            get {
+                return ResourceManager.GetString("STP", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to STore X to memory.
+        /// </summary>
+        internal static string STX {
+            get {
+                return ResourceManager.GetString("STX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to STore Y to memory.
+        /// </summary>
+        internal static string STY {
+            get {
+                return ResourceManager.GetString("STY", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to STore Zero to memory.
+        /// </summary>
+        internal static string STZ {
+            get {
+                return ResourceManager.GetString("STZ", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer Accumulator to X.
+        /// </summary>
+        internal static string TAX {
+            get {
+                return ResourceManager.GetString("TAX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer Accumulator to Y.
+        /// </summary>
+        internal static string TAY {
+            get {
+                return ResourceManager.GetString("TAY", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer aCcumulator to Direct page.
+        /// </summary>
+        internal static string TCD {
+            get {
+                return ResourceManager.GetString("TCD", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer aCcumulator to Stack page.
+        /// </summary>
+        internal static string TCS {
+            get {
+                return ResourceManager.GetString("TCS", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer Direct page to aCcumulator.
+        /// </summary>
+        internal static string TDC {
+            get {
+                return ResourceManager.GetString("TDC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Test and Reset Bit.
+        /// </summary>
+        internal static string TRB {
+            get {
+                return ResourceManager.GetString("TRB", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Test and Set Bit.
+        /// </summary>
+        internal static string TSB {
+            get {
+                return ResourceManager.GetString("TSB", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer Stack pointer to aCcumulator.
+        /// </summary>
+        internal static string TSC {
+            get {
+                return ResourceManager.GetString("TSC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer Stack pointer to X.
+        /// </summary>
+        internal static string TSX {
+            get {
+                return ResourceManager.GetString("TSX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer X to Accumulator.
+        /// </summary>
+        internal static string TXA {
+            get {
+                return ResourceManager.GetString("TXA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer X to Stack pointer.
+        /// </summary>
+        internal static string TXS {
+            get {
+                return ResourceManager.GetString("TXS", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer X to Y.
+        /// </summary>
+        internal static string TXY {
+            get {
+                return ResourceManager.GetString("TXY", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer Y to Accumulator.
+        /// </summary>
+        internal static string TYA {
+            get {
+                return ResourceManager.GetString("TYA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transfer Y to X.
+        /// </summary>
+        internal static string TYX {
+            get {
+                return ResourceManager.GetString("TYX", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to WAIt for interrupt.
+        /// </summary>
+        internal static string WAI {
+            get {
+                return ResourceManager.GetString("WAI", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Reserved for future use, it performs no operation.
+        /// </summary>
+        internal static string WDM {
+            get {
+                return ResourceManager.GetString("WDM", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to EXchange low and high byte of the Accumulator.
+        /// </summary>
+        internal static string XBA {
+            get {
+                return ResourceManager.GetString("XBA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to EXchange Carry and Emulation.
+        /// </summary>
+        internal static string XCE {
+            get {
+                return ResourceManager.GetString("XCE", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/Resources/opcodes.resx b/Resources/opcodes.resx
new file mode 100644
index 0000000..3e5f8d2
--- /dev/null
+++ b/Resources/opcodes.resx
@@ -0,0 +1,423 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ADC" xml:space="preserve">
+    <value>ADd with Carry</value>
+  </data>
+  <data name="ADCL" xml:space="preserve">
+    <value>ADd with Carry Long</value>
+  </data>
+  <data name="AND" xml:space="preserve">
+    <value>Bitwise AND with accumulator</value>
+  </data>
+  <data name="ANDL" xml:space="preserve">
+    <value>Bitwise AND with accumulator, Long</value>
+  </data>
+  <data name="ASL" xml:space="preserve">
+    <value>ASL shifts all bits left one position. 0 is shifted into bit 0 and the original bit 7 is shifted into the Carry</value>
+  </data>
+  <data name="BCC" xml:space="preserve">
+    <value>Branch if Carry Clear</value>
+  </data>
+  <data name="BCS" xml:space="preserve">
+    <value>Branch if Carry Set</value>
+  </data>
+  <data name="BEQ" xml:space="preserve">
+    <value>Branch if EQual/Branch if zero</value>
+  </data>
+  <data name="BIT" xml:space="preserve">
+    <value>BIt Test</value>
+  </data>
+  <data name="BMI" xml:space="preserve">
+    <value>Branch if MInus value</value>
+  </data>
+  <data name="BNE" xml:space="preserve">
+    <value>Branch if Not Equal/Branch if not zero</value>
+  </data>
+  <data name="BPL" xml:space="preserve">
+    <value>Branch if PLus value</value>
+  </data>
+  <data name="BRA" xml:space="preserve">
+    <value>BRanch Always</value>
+  </data>
+  <data name="BRK" xml:space="preserve">
+    <value>Software BReaK</value>
+  </data>
+  <data name="BRL" xml:space="preserve">
+    <value>BRanch always Long</value>
+  </data>
+  <data name="BVC" xml:space="preserve">
+    <value>Branch if oVerflow Clear</value>
+  </data>
+  <data name="BVS" xml:space="preserve">
+    <value>Branch if oVerflow Set</value>
+  </data>
+  <data name="CLC" xml:space="preserve">
+    <value>CLear Carry flag</value>
+  </data>
+  <data name="CLD" xml:space="preserve">
+    <value>CLear Decimal flag</value>
+  </data>
+  <data name="CLI" xml:space="preserve">
+    <value>CLear Interrupt flag</value>
+  </data>
+  <data name="CLV" xml:space="preserve">
+    <value>CLear oVerflow flag</value>
+  </data>
+  <data name="CMP" xml:space="preserve">
+    <value>CoMPare accumulator with memory</value>
+  </data>
+  <data name="CMPL" xml:space="preserve">
+    <value>CoMPare accumulator with memory, Long</value>
+  </data>
+  <data name="COP" xml:space="preserve">
+    <value>COProcessor empowerment (interrupt)</value>
+  </data>
+  <data name="CPX" xml:space="preserve">
+    <value>ComPare X with memory</value>
+  </data>
+  <data name="CPY" xml:space="preserve">
+    <value>ComPare Y with memory</value>
+  </data>
+  <data name="DEC" xml:space="preserve">
+    <value>DECrement accumulator or memory</value>
+  </data>
+  <data name="DEX" xml:space="preserve">
+    <value>DEcrement X</value>
+  </data>
+  <data name="DEY" xml:space="preserve">
+    <value>Decrement Y</value>
+  </data>
+  <data name="EOR" xml:space="preserve">
+    <value>Exclusive OR accumulator with memory</value>
+  </data>
+  <data name="EORL" xml:space="preserve">
+    <value>Exclusive OR accumulator with memory, Long</value>
+  </data>
+  <data name="INC" xml:space="preserve">
+    <value>INCrement accumulator or memory</value>
+  </data>
+  <data name="INX" xml:space="preserve">
+    <value>INcrement X</value>
+  </data>
+  <data name="INY" xml:space="preserve">
+    <value>INcrement Y</value>
+  </data>
+  <data name="JML" xml:space="preserve">
+    <value>JuMp, Long</value>
+  </data>
+  <data name="JMP" xml:space="preserve">
+    <value>JuMP</value>
+  </data>
+  <data name="JMPL" xml:space="preserve">
+    <value>JuMP, Long</value>
+  </data>
+  <data name="JSL" xml:space="preserve">
+    <value>Jump to Subroutine, Long</value>
+  </data>
+  <data name="JSR" xml:space="preserve">
+    <value>Jump to SubRoutine</value>
+  </data>
+  <data name="LDA" xml:space="preserve">
+    <value>LoaD Accumulator</value>
+  </data>
+  <data name="LDAL" xml:space="preserve">
+    <value>LoaD Accumulator, Long</value>
+  </data>
+  <data name="LDX" xml:space="preserve">
+    <value>LoaD X register</value>
+  </data>
+  <data name="LDY" xml:space="preserve">
+    <value>LoaD Y register</value>
+  </data>
+  <data name="LSR" xml:space="preserve">
+    <value>LSR shifts all bits right one position. 0 is shifted into bit 7 and the original bit 0 is shifted into the Carry</value>
+  </data>
+  <data name="MVN" xml:space="preserve">
+    <value>Block MoVe Negative</value>
+  </data>
+  <data name="MVP" xml:space="preserve">
+    <value>Block MoVe Positive</value>
+  </data>
+  <data name="NOP" xml:space="preserve">
+    <value>No OPeration</value>
+  </data>
+  <data name="ORA" xml:space="preserve">
+    <value>Bitwise OR Accumulator with memory</value>
+  </data>
+  <data name="ORAL" xml:space="preserve">
+    <value>Bitwise OR Accumulator with memory, Long</value>
+  </data>
+  <data name="PEA" xml:space="preserve">
+    <value>Push Effective Address</value>
+  </data>
+  <data name="PEI" xml:space="preserve">
+    <value>Push Effective Indirect address</value>
+  </data>
+  <data name="PER" xml:space="preserve">
+    <value>Push program countEr Relative</value>
+  </data>
+  <data name="PHA" xml:space="preserve">
+    <value>PusH Accumulator</value>
+  </data>
+  <data name="PHB" xml:space="preserve">
+    <value>PusH data Bank register</value>
+  </data>
+  <data name="PHD" xml:space="preserve">
+    <value>PusH Direct page register</value>
+  </data>
+  <data name="PHK" xml:space="preserve">
+    <value>PusH program banK register</value>
+  </data>
+  <data name="PHP" xml:space="preserve">
+    <value>PusH Processor status flags</value>
+  </data>
+  <data name="PHX" xml:space="preserve">
+    <value>PusH X</value>
+  </data>
+  <data name="PHY" xml:space="preserve">
+    <value>PusH Y</value>
+  </data>
+  <data name="PLA" xml:space="preserve">
+    <value>Pull Accumulator</value>
+  </data>
+  <data name="PLB" xml:space="preserve">
+    <value>Pull data Bank register</value>
+  </data>
+  <data name="PLD" xml:space="preserve">
+    <value>Pull Direct page register</value>
+  </data>
+  <data name="PLP" xml:space="preserve">
+    <value>Pull Processor status flags</value>
+  </data>
+  <data name="PLX" xml:space="preserve">
+    <value>Pull X</value>
+  </data>
+  <data name="PLY" xml:space="preserve">
+    <value>Pull Y</value>
+  </data>
+  <data name="REP" xml:space="preserve">
+    <value>REset Processor status flag</value>
+  </data>
+  <data name="ROL" xml:space="preserve">
+    <value>ROtate Left accumulator or memory</value>
+  </data>
+  <data name="ROR" xml:space="preserve">
+    <value>ROtate Right accumulator or memory</value>
+  </data>
+  <data name="RTI" xml:space="preserve">
+    <value>ReTurn from Interrupt</value>
+  </data>
+  <data name="RTL" xml:space="preserve">
+    <value>ReTurn from subroutine, Long</value>
+  </data>
+  <data name="RTS" xml:space="preserve">
+    <value>ReTurn from Subroutine; pulls the top two bytes off the stack (low byte first) and transfers program control to that address+1</value>
+  </data>
+  <data name="SBC" xml:space="preserve">
+    <value>SuBtract with Carry</value>
+  </data>
+  <data name="SBCL" xml:space="preserve">
+    <value>SuBtract with Carry Long</value>
+  </data>
+  <data name="SEC" xml:space="preserve">
+    <value>SEt Carry flag</value>
+  </data>
+  <data name="SED" xml:space="preserve">
+    <value>SEt Decimal flag</value>
+  </data>
+  <data name="SEI" xml:space="preserve">
+    <value>SEt Interrupt flag</value>
+  </data>
+  <data name="SEP" xml:space="preserve">
+    <value>SEt Processor status flag</value>
+  </data>
+  <data name="STA" xml:space="preserve">
+    <value>STore Accumulator to memory</value>
+  </data>
+  <data name="STAL" xml:space="preserve">
+    <value>STore Accumulator to memory, Long</value>
+  </data>
+  <data name="STP" xml:space="preserve">
+    <value>SToP the clock</value>
+  </data>
+  <data name="STX" xml:space="preserve">
+    <value>STore X to memory</value>
+  </data>
+  <data name="STY" xml:space="preserve">
+    <value>STore Y to memory</value>
+  </data>
+  <data name="STZ" xml:space="preserve">
+    <value>STore Zero to memory</value>
+  </data>
+  <data name="TAX" xml:space="preserve">
+    <value>Transfer Accumulator to X</value>
+  </data>
+  <data name="TAY" xml:space="preserve">
+    <value>Transfer Accumulator to Y</value>
+  </data>
+  <data name="TCD" xml:space="preserve">
+    <value>Transfer aCcumulator to Direct page</value>
+  </data>
+  <data name="TCS" xml:space="preserve">
+    <value>Transfer aCcumulator to Stack page</value>
+  </data>
+  <data name="TDC" xml:space="preserve">
+    <value>Transfer Direct page to aCcumulator</value>
+  </data>
+  <data name="TRB" xml:space="preserve">
+    <value>Test and Reset Bit</value>
+  </data>
+  <data name="TSB" xml:space="preserve">
+    <value>Test and Set Bit</value>
+  </data>
+  <data name="TSC" xml:space="preserve">
+    <value>Transfer Stack pointer to aCcumulator</value>
+  </data>
+  <data name="TSX" xml:space="preserve">
+    <value>Transfer Stack pointer to X</value>
+  </data>
+  <data name="TXA" xml:space="preserve">
+    <value>Transfer X to Accumulator</value>
+  </data>
+  <data name="TXS" xml:space="preserve">
+    <value>Transfer X to Stack pointer</value>
+  </data>
+  <data name="TXY" xml:space="preserve">
+    <value>Transfer X to Y</value>
+  </data>
+  <data name="TYA" xml:space="preserve">
+    <value>Transfer Y to Accumulator</value>
+  </data>
+  <data name="TYX" xml:space="preserve">
+    <value>Transfer Y to X</value>
+  </data>
+  <data name="WAI" xml:space="preserve">
+    <value>WAIt for interrupt</value>
+  </data>
+  <data name="WDM" xml:space="preserve">
+    <value>Reserved for future use, it performs no operation</value>
+  </data>
+  <data name="XBA" xml:space="preserve">
+    <value>EXchange low and high byte of the Accumulator</value>
+  </data>
+  <data name="XCE" xml:space="preserve">
+    <value>EXchange Carry and Emulation</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/Test/HelloWorld.s b/Test/HelloWorld.s
new file mode 100644
index 0000000..9027fd7
--- /dev/null
+++ b/Test/HelloWorld.s
@@ -0,0 +1,11 @@
+; Uses S-C Assembler variant.
+* This is also a valid comment...
+            org $800
+main        ldy #$00
+start_loop  lda HelloWorld,y
+            beq end_loop 
+            jsr $fded ; ROM routine, COUT, y is preserved
+            iny
+            bne start_loop
+end_loop    rts
+HelloWorld	ASC "HELLO WORLD!"00
diff --git a/VSLanguageServiceIcon.jpg b/VSLanguageServiceIcon.jpg
new file mode 100644
index 0000000..87a5bdb
Binary files /dev/null and b/VSLanguageServiceIcon.jpg differ
diff --git a/VSLanguageServicePreviewImage.jpg b/VSLanguageServicePreviewImage.jpg
new file mode 100644
index 0000000..6cc9bc1
Binary files /dev/null and b/VSLanguageServicePreviewImage.jpg differ
diff --git a/source.extension.vsixmanifest b/source.extension.vsixmanifest
new file mode 100644
index 0000000..017a409
--- /dev/null
+++ b/source.extension.vsixmanifest
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--//***************************************************************************
+//
+//    Copyright (c) Microsoft Corporation. All rights reserved.
+//    This code is licensed under the Visual Studio SDK license terms.
+//    THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+//    ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+//    IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+//    PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//***************************************************************************-->
+<PackageManifest Version="2.0.0" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011">
+  <Metadata>
+    <Identity Id="Merlin32Language..c729d6b2-f512-49ed-893d-a8f61f25db98" Version="1.0" Language="en-US" Publisher="Olivier Guinart" />
+    <DisplayName>Merlin32 Language Service</DisplayName>
+    <Description xml:space="preserve">Merlin32 classifier extension to the Visual Studio Editor.</Description>
+    <MoreInfo>http://www.brutaldeluxe.fr/products/crossdevtools/merlin/</MoreInfo>
+    <License>License.txt</License>
+    <GettingStartedGuide>https://github.com/OlivierGuinart/Merlin32Language</GettingStartedGuide>
+    <Icon>VSLanguageServiceIcon.jpg</Icon>
+    <PreviewImage>VSLanguageServicePreviewImage.jpg</PreviewImage>
+    <Tags>6502, merlin32, assembly language, language service, Apple II</Tags>
+  </Metadata>
+  <Installation>
+    <InstallationTarget Id="Microsoft.VisualStudio.Pro" Version="[12.0,15.0)" />
+    <InstallationTarget Version="[12.0,15.0)" Id="Microsoft.VisualStudio.IntegratedShell" />
+    <InstallationTarget Version="[12.0,15.0)" Id="Microsoft.VisualStudio.Community" />
+    <InstallationTarget Version="[12.0,15.0)" Id="Microsoft.VisualStudio.Enterprise" />
+  </Installation>
+  <Dependencies>
+    <Dependency Id="Microsoft.Framework.NDP" DisplayName="Microsoft .NET Framework" d:Source="Manual" Version="4.5" />
+  </Dependencies>
+  <Assets>
+    <Asset Type="Microsoft.VisualStudio.MefComponent" d:Source="Project" d:ProjectName="%CurrentProject%" Path="|%CurrentProject%|" />
+  </Assets>
+</PackageManifest>
\ No newline at end of file