diff --git a/VS/CSHARP/asm-dude-vsix/CodeCompletion/CodeCompletionSource.cs b/VS/CSHARP/asm-dude-vsix/CodeCompletion/CodeCompletionSource.cs
index e423fec9..608cb6f1 100644
--- a/VS/CSHARP/asm-dude-vsix/CodeCompletion/CodeCompletionSource.cs
+++ b/VS/CSHARP/asm-dude-vsix/CodeCompletion/CodeCompletionSource.cs
@@ -269,7 +269,7 @@ private IEnumerable<Completion> Mnemonic_Operand_Completions(bool useCapitals, I
             SortedSet<Completion> completions = new SortedSet<Completion>(new CompletionComparer());
             foreach (string keyword in this._asmDudeTools.Get_Keywords())
             {
-                AsmTokenType type = this._asmDudeTools.Get_Token_Type(keyword);
+                AsmTokenType type = this._asmDudeTools.Get_Token_Type_Intel(keyword);
 
                 Arch arch = this._asmDudeTools.Get_Architecture(keyword);
                 bool selected = Is_Register_Switched_On(arch);
@@ -431,7 +431,7 @@ private IEnumerable<Completion> Selected_Completions(bool useCapitals, ISet<AsmT
             //Add the completions that are defined in the xml file
             foreach (string keyword in this._asmDudeTools.Get_Keywords())
             {
-                AsmTokenType type = this._asmDudeTools.Get_Token_Type(keyword);
+                AsmTokenType type = this._asmDudeTools.Get_Token_Type_Intel(keyword);
                 if (selectedTypes.Contains(type))
                 {
                     Arch arch = Arch.NONE;
@@ -444,9 +444,9 @@ private IEnumerable<Completion> Selected_Completions(bool useCapitals, ISet<AsmT
                         {
                             if (!usedAssember.HasFlag(AssemblerEnum.MASM)) selected = false;
                         }
-                        else if (assembler.HasFlag(AssemblerEnum.NASM))
+                        else if (assembler.HasFlag(AssemblerEnum.NASM_INTEL) || assembler.HasFlag(AssemblerEnum.NASM_ATT))
                         {
-                            if (!usedAssember.HasFlag(AssemblerEnum.NASM)) selected = false;
+                            if (!usedAssember.HasFlag(AssemblerEnum.NASM_INTEL)) selected = false;
                         }
                     }
                     else
diff --git a/VS/CSHARP/asm-dude-vsix/CodeFolding/CodeFoldingTagger.cs b/VS/CSHARP/asm-dude-vsix/CodeFolding/CodeFoldingTagger.cs
index 65dd2370..73e9a10f 100644
--- a/VS/CSHARP/asm-dude-vsix/CodeFolding/CodeFoldingTagger.cs
+++ b/VS/CSHARP/asm-dude-vsix/CodeFolding/CodeFoldingTagger.cs
@@ -225,7 +225,7 @@ private TextBlock Get_Hover_Text_TextBlock(int beginLineNumber, int endLineNumbe
                 {
                     return Is_Start_Masm_Keyword(lineContent, lineNumber);
                 }
-                else if (usedAssember.HasFlag(AssemblerEnum.NASM))
+                else if (usedAssember.HasFlag(AssemblerEnum.NASM_INTEL) || usedAssember.HasFlag(AssemblerEnum.NASM_ATT))
                 {
                     return Is_Start_Nasm_Keyword(lineContent, lineNumber);
                 }
@@ -330,7 +330,7 @@ private int Is_End_Keyword(string lineContent, int lineNumber)
                 {
                     return Is_End_Masm_Keyword(lineContent, lineNumber);
                 }
-                else if (usedAssember.HasFlag(AssemblerEnum.NASM))
+                else if (usedAssember.HasFlag(AssemblerEnum.NASM_INTEL) || usedAssember.HasFlag(AssemblerEnum.NASM_ATT))
                 {
                     return Is_End_Nasm_Keyword(lineContent, lineNumber);
                 }
diff --git a/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionPageUI.xaml b/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionPageUI.xaml
index 84eced2b..1a6f1eff 100644
--- a/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionPageUI.xaml
+++ b/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionPageUI.xaml
@@ -9,15 +9,16 @@
         <ScrollViewer>
             <StackPanel>
                 <Label x:Name="version_UI" Content="AsmDude version" />
+                <Grid>
+                    <Label Content="Flavor:" HorizontalAlignment="Left"/>
+                    <RadioButton x:Name="usedAssemblerMasm_UI" GroupName="usedAssembler_UI" ToolTip="Configure AsmDude for Intel syntax MASM" Content="Intel Masm" Margin="140,5,0,0" HorizontalAlignment="Left" Width="Auto" />
+                    <RadioButton x:Name="usedAssemblerNasm_UI" GroupName="usedAssembler_UI" ToolTip="Configure AsmDude for Intel syntax NASM" Content="Intel Nasm" Margin="240,5,0,0" HorizontalAlignment="Left" Width="Auto" />
+                    <RadioButton x:Name="usedAssemblerAtt_UI" GroupName="usedAssembler_UI" ToolTip="Configure AsmDude for AT&amp;T syntax NASM" Content="AT&amp;T Nasm" Margin="340,5,0,0" HorizontalAlignment="Left" Width="Auto" />
+                </Grid>
                 <GroupBox Header="Syntax Highlighting" BorderBrush="DarkGray">
                     <Grid>
                         <StackPanel>
                             <CheckBox x:Name="SyntaxHighlighting_On_UI" ToolTip="Syntax highlighting enabled" Content="Enable syntax highlighting" Margin="0,4,0,4" HorizontalAlignment="Left" Width="Auto" />
-                            <Grid>
-                                <Label Content="Compiler:" HorizontalAlignment="Left"/>
-                                <RadioButton x:Name="usedAssemblerMasm_UI" GroupName="usedAssembler_UI" ToolTip="Enable syntax highlighting for MASM" Content="Masm" Margin="140,5,0,0" HorizontalAlignment="Left" Width="Auto" />
-                                <RadioButton x:Name="usedAssemblerNasm_UI" GroupName="usedAssembler_UI" ToolTip="Enable syntax highlighting for NASM" Content="Nasm" Margin="240,5,0,0" HorizontalAlignment="Left" Width="Auto" />
-                            </Grid>
                             <Grid>
                                 <Label Content="Mnemonic:" HorizontalAlignment="Left"/>
                                 <CheckBox x:Name="ColorMnemonic_Italic_UI" Content="Italic" Margin="130,6,0,2" HorizontalAlignment="Left" Width="Auto" />
diff --git a/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionPageUI.xaml.cs b/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionPageUI.xaml.cs
index b950b9eb..6a7d5b13 100644
--- a/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionPageUI.xaml.cs
+++ b/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionPageUI.xaml.cs
@@ -50,7 +50,6 @@ public AsmDudeOptionsPageUI()
         }
 
         #region Event Handlers to disable options
-
         private void SyntaxHighlighting_Update(bool value)
         {
             this.ColorMnemonic_UI.IsEnabled = value;
@@ -76,8 +75,7 @@ private void SyntaxHighlighting_Update(bool value)
             this.ColorUserDefined3_UI.IsEnabled = value;
             this.ColorUserDefined3_Italic_UI.IsEnabled = value;
         }
-
-    private void AsmDoc_Update(bool value)
+        private void AsmDoc_Update(bool value)
         {
             this.AsmDoc_Url_UI.IsEnabled = value;
         }
@@ -118,25 +116,54 @@ public string AsmDoc_Url
         }
         #endregion Asm Documentation
 
+        public AssemblerEnum UsedAssembler
+        {
+            get
+            {
+                if (this.usedAssemblerMasm_UI.IsChecked.HasValue && this.usedAssemblerMasm_UI.IsChecked.Value) return AssemblerEnum.MASM;
+                if (this.usedAssemblerNasm_UI.IsChecked.HasValue && this.usedAssemblerNasm_UI.IsChecked.Value) return AssemblerEnum.NASM_INTEL;
+                if (this.usedAssemblerAtt_UI.IsChecked.HasValue && this.usedAssemblerAtt_UI.IsChecked.Value) return AssemblerEnum.NASM_ATT;
+                return AssemblerEnum.MASM; // if nothing is checked somehow return MASM
+            }
+            set
+            {
+                if (value.HasFlag(AssemblerEnum.MASM))
+                {
+                    this.usedAssemblerMasm_UI.IsChecked = true;
+                    this.usedAssemblerNasm_UI.IsChecked = false;
+                    this.usedAssemblerAtt_UI.IsChecked = false;
+                }
+                else if (value.HasFlag(AssemblerEnum.NASM_INTEL))
+                {
+                    this.usedAssemblerMasm_UI.IsChecked = false;
+                    this.usedAssemblerNasm_UI.IsChecked = true;
+                    this.usedAssemblerAtt_UI.IsChecked = false;
+                }
+                else if (value.HasFlag(AssemblerEnum.NASM_ATT))
+                {
+                    this.usedAssemblerMasm_UI.IsChecked = false;
+                    this.usedAssemblerNasm_UI.IsChecked = false;
+                    this.usedAssemblerAtt_UI.IsChecked = true;
+                }
+            }
+        }
+
         #region Code Folding
         public bool CodeFolding_On
         {
             get { return this.CodeFolding_On_UI.IsChecked ?? false; }
             set { this.CodeFolding_On_UI.IsChecked = value; }
         }
-
         public bool CodeFolding_IsDefaultCollaped
         {
             get { return this.CodeFolding_IsDefaultCollaped_UI.IsChecked ?? false; }
             set { this.CodeFolding_IsDefaultCollaped_UI.IsChecked = value; }
         }
-
         public string CodeFolding_BeginTag
         {
             get { return this.CodeFolding_BeginTag_UI.Text; }
             set { this.CodeFolding_BeginTag_UI.Text = value; }
         }
-
         public string CodeFolding_EndTag
         {
             get { return this.CodeFolding_EndTag_UI.Text; }
@@ -152,29 +179,6 @@ public bool SyntaxHighlighting_On
             set { this.SyntaxHighlighting_On_UI.IsChecked = value; }
         }
 
-        public AssemblerEnum UsedAssembler
-        {
-            get
-            {
-                if (this.usedAssemblerMasm_UI.IsChecked.HasValue && this.usedAssemblerMasm_UI.IsChecked.Value) return AssemblerEnum.MASM;
-                if (this.usedAssemblerNasm_UI.IsChecked.HasValue && this.usedAssemblerNasm_UI.IsChecked.Value) return AssemblerEnum.NASM;
-                return AssemblerEnum.MASM;
-            }
-            set
-            {
-                if (value.HasFlag(AssemblerEnum.MASM))
-                {
-                    this.usedAssemblerMasm_UI.IsChecked = true;
-                    this.usedAssemblerNasm_UI.IsChecked = false;
-                }
-                else if (value.HasFlag(AssemblerEnum.NASM))
-                {
-                    this.usedAssemblerMasm_UI.IsChecked = false;
-                    this.usedAssemblerNasm_UI.IsChecked = true;
-                }
-            }
-        }
-
         public System.Drawing.Color ColorMnemonic
         {
             get { return (this.ColorMnemonic_UI.SelectedColor.HasValue) ? AsmDudeToolsStatic.ConvertColor(this.ColorMnemonic_UI.SelectedColor.Value) : System.Drawing.Color.Blue; }
diff --git a/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionsPage.cs b/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionsPage.cs
index 79fea3d4..affc6e34 100644
--- a/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionsPage.cs
+++ b/VS/CSHARP/asm-dude-vsix/OptionsPage/AsmDudeOptionsPage.cs
@@ -64,6 +64,8 @@ protected override void OnActivate(CancelEventArgs e)
         {
             base.OnActivate(e);
 
+            this._asmDudeOptionsPageUI.UsedAssembler = AsmDudeToolsStatic.Used_Assembler;
+
             #region AsmDoc
             this._asmDudeOptionsPageUI.AsmDoc_On = Settings.Default.AsmDoc_On;
             this._asmDudeOptionsPageUI.AsmDoc_Url = Settings.Default.AsmDoc_url;
@@ -78,8 +80,6 @@ protected override void OnActivate(CancelEventArgs e)
 
             #region Syntax Highlighting
             this._asmDudeOptionsPageUI.SyntaxHighlighting_On = Settings.Default.SyntaxHighlighting_On;
-            this._asmDudeOptionsPageUI.UsedAssembler = AsmDudeToolsStatic.Used_Assembler;
-
             this._asmDudeOptionsPageUI.ColorMnemonic = Settings.Default.SyntaxHighlighting_Opcode;
             this._asmDudeOptionsPageUI.ColorMnemonic_Italic = Settings.Default.SyntaxHighlighting_Opcode_Italic;
             this._asmDudeOptionsPageUI.ColorRegister = Settings.Default.SyntaxHighlighting_Register;
@@ -330,6 +330,12 @@ protected override void OnDeactivate(CancelEventArgs e)
         {
             bool changed = false;
 
+            if (AsmDudeToolsStatic.Used_Assembler != this._asmDudeOptionsPageUI.UsedAssembler)
+            {
+                if (logInfo) AsmDudeToolsStatic.Output("INFO: AsmDudeOptionsPage: OnDeactivate: change detected: usedAssembler=" + this._asmDudeOptionsPageUI.UsedAssembler);
+                changed = true;
+            }
+
             #region AsmDoc
             if (Settings.Default.AsmDoc_On != this._asmDudeOptionsPageUI.AsmDoc_On)
             {
@@ -372,11 +378,6 @@ protected override void OnDeactivate(CancelEventArgs e)
                 if (logInfo) AsmDudeToolsStatic.Output("INFO: AsmDudeOptionsPage: OnDeactivate: change detected: useSyntaxHighlighting=" + this._asmDudeOptionsPageUI.SyntaxHighlighting_On);
                 changed = true;
             }
-            if (AsmDudeToolsStatic.Used_Assembler != this._asmDudeOptionsPageUI.UsedAssembler)
-            {
-                if (logInfo) AsmDudeToolsStatic.Output("INFO: AsmDudeOptionsPage: OnDeactivate: change detected: usedAssembler=" + this._asmDudeOptionsPageUI.UsedAssembler);
-                changed = true;
-            }
             if (Settings.Default.SyntaxHighlighting_Opcode.ToArgb() != this._asmDudeOptionsPageUI.ColorMnemonic.ToArgb())
             {
                 if (logInfo) AsmDudeToolsStatic.Output("INFO: AsmDudeOptionsPage: OnDeactivate: change detected: stored=" + Settings.Default.SyntaxHighlighting_Opcode + "; new colorMnemonic=" + this._asmDudeOptionsPageUI.ColorMnemonic);
@@ -904,8 +905,8 @@ protected override void OnDeactivate(CancelEventArgs e)
                 if (!this._asmDudeOptionsPageUI.AsmSim_On)
                 {
                     string title = null;
-                    string message = "I'm sorry "+ Environment.UserName + ", I'm afraid I can't do that";
-                    int result = VsShellUtilities.ShowMessageBox(this.Site, message, title, OLEMSGICON.OLEMSGICON_QUERY, OLEMSGBUTTON.OLEMSGBUTTON_OKCANCEL, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST);
+                    string message = "I'm sorry "+ Environment.UserName + ", I'm afraid I can't do that.";
+                    int result = VsShellUtilities.ShowMessageBox(this.Site, message, title, OLEMSGICON.OLEMSGICON_QUERY, OLEMSGBUTTON.OLEMSGBUTTON_ABORTRETRYIGNORE, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST);
                 }
             }
             if (Settings.Default.AsmSim_Number_Of_Steps != this._asmDudeOptionsPageUI.AsmSim_Number_Of_Steps)
@@ -1004,6 +1005,14 @@ private void Save()
             //Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "INFO:{0}:save", this.ToString()));
             bool changed = false;
             bool restartNeeded = false;
+
+            if (AsmDudeToolsStatic.Used_Assembler != this._asmDudeOptionsPageUI.UsedAssembler)
+            {
+                AsmDudeToolsStatic.Used_Assembler = this._asmDudeOptionsPageUI.UsedAssembler;
+                changed = true;
+                restartNeeded = true;
+            }
+
             #region AsmDoc
             if (Settings.Default.AsmDoc_On != this._asmDudeOptionsPageUI.AsmDoc_On)
             {
@@ -1052,12 +1061,6 @@ private void Save()
                 changed = true;
                 restartNeeded = true;
             }
-            if (AsmDudeToolsStatic.Used_Assembler != this._asmDudeOptionsPageUI.UsedAssembler)
-            {
-                AsmDudeToolsStatic.Used_Assembler = this._asmDudeOptionsPageUI.UsedAssembler;
-                changed = true;
-                restartNeeded = true;
-            }
             if (Settings.Default.SyntaxHighlighting_Opcode.ToArgb() != this._asmDudeOptionsPageUI.ColorMnemonic.ToArgb())
             {
                 Settings.Default.SyntaxHighlighting_Opcode = this._asmDudeOptionsPageUI.ColorMnemonic;
@@ -1685,7 +1688,7 @@ private void Save()
             if (restartNeeded)
             {
                 string title = null;
-                string message = "You may need to restart visual studio for the changes to take effect.";
+                string message = "You may need to close and open assembly files, or \nrestart visual studio for the changes to take effect.";
                 int result = VsShellUtilities.ShowMessageBox(this.Site, message, title, OLEMSGICON.OLEMSGICON_QUERY, OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST);
             }
         }
diff --git a/VS/CSHARP/asm-dude-vsix/QuickInfo/AsmQuickInfoSource.cs b/VS/CSHARP/asm-dude-vsix/QuickInfo/AsmQuickInfoSource.cs
index 44dff397..7a182ea8 100644
--- a/VS/CSHARP/asm-dude-vsix/QuickInfo/AsmQuickInfoSource.cs
+++ b/VS/CSHARP/asm-dude-vsix/QuickInfo/AsmQuickInfoSource.cs
@@ -176,9 +176,12 @@ private void Handle(IQuickInfoSession session, IList<object> quickInfoContent, o
                             }
                         case AsmTokenType.Register:
                             {
+                                if (keywordUpper.StartsWith("%")) keywordUpper = keywordUpper.Substring(1); // remove the preceding % in AT&T syntax 
+                                Rn reg = RegisterTools.ParseRn(keywordUpper, true);
+
                                 description = new TextBlock();
                                 description.Inlines.Add(Make_Run1("Register ", this._foreground));
-                                description.Inlines.Add(Make_Run2(keyword, new SolidColorBrush(AsmDudeToolsStatic.ConvertColor(Settings.Default.SyntaxHighlighting_Register))));
+                                description.Inlines.Add(Make_Run2(reg.ToString(), new SolidColorBrush(AsmDudeToolsStatic.ConvertColor(Settings.Default.SyntaxHighlighting_Register))));
 
                                 string descr = this._asmDudeTools.Get_Description(keywordUpper);
                                 if (descr.Length > 0)
@@ -192,7 +195,6 @@ private void Handle(IQuickInfoSession session, IList<object> quickInfoContent, o
 
                                 if (this._asmSimulator.Enabled & Settings.Default.AsmSim_Decorate_Registers)
                                 {
-                                    Rn reg = RegisterTools.ParseRn(keywordUpper, true);
                                     string reg_Content_Before = this._asmSimulator.Get_Register_Value(reg, lineNumber, true, false, false).Value;
                                     string reg_Content_After = this._asmSimulator.Get_Register_Value(reg, lineNumber, false, false, false).Value;
                                     string msg = "\n" + reg + " before: " + reg_Content_Before + "\n" + reg + " after:  " + reg_Content_After;
@@ -206,14 +208,15 @@ private void Handle(IQuickInfoSession session, IList<object> quickInfoContent, o
                         case AsmTokenType.Mnemonic:
                         case AsmTokenType.Jump:
                             {
+                                Mnemonic mnemonic = AsmSourceTools.ParseMnemonic_Att(keywordUpper, true);
+
                                 description = new TextBlock();
                                 description.Inlines.Add(Make_Run1("Mnemonic ", this._foreground));
-                                description.Inlines.Add(Make_Run2(keyword, new SolidColorBrush(AsmDudeToolsStatic.ConvertColor((type == AsmTokenType.Mnemonic) ? Settings.Default.SyntaxHighlighting_Opcode : Settings.Default.SyntaxHighlighting_Jump))));
+                                description.Inlines.Add(Make_Run2(mnemonic.ToString(), new SolidColorBrush(AsmDudeToolsStatic.ConvertColor((type == AsmTokenType.Mnemonic) ? Settings.Default.SyntaxHighlighting_Opcode : Settings.Default.SyntaxHighlighting_Jump))));
 
-                                Mnemonic mmemonic = AsmSourceTools.ParseMnemonic(keywordUpper, true);
                                 {
-                                    string archStr = ":" + ArchTools.ToString(this._asmDudeTools.Mnemonic_Store.GetArch(mmemonic)) + " ";
-                                    string descr = this._asmDudeTools.Mnemonic_Store.GetDescription(mmemonic);
+                                    string archStr = ":" + ArchTools.ToString(this._asmDudeTools.Mnemonic_Store.GetArch(mnemonic)) + " ";
+                                    string descr = this._asmDudeTools.Mnemonic_Store.GetDescription(mnemonic);
                                     if (keyword.Length > (AsmDudePackage.maxNumberOfCharsInToolTips / 2)) descr = "\n" + descr;
                                     description.Inlines.Add(new Run(AsmSourceTools.Linewrap(archStr + descr, AsmDudePackage.maxNumberOfCharsInToolTips))
                                     {
@@ -221,7 +224,7 @@ private void Handle(IQuickInfoSession session, IList<object> quickInfoContent, o
                                     });
                                 }
                                 // add performance information
-                                this.Add_Performance_Description(description, mmemonic);
+                                this.Add_Performance_Description(description, mnemonic);
                                 break;
                             }
                         case AsmTokenType.Label:
diff --git a/VS/CSHARP/asm-dude-vsix/Resources/examples/example_att.s b/VS/CSHARP/asm-dude-vsix/Resources/examples/example_att.s
new file mode 100644
index 00000000..1fe5ee5a
--- /dev/null
+++ b/VS/CSHARP/asm-dude-vsix/Resources/examples/example_att.s
@@ -0,0 +1,19 @@
+       .text
+LC0:
+        .ascii "Hello, world!\12\0"
+.globl _main
+_main:
+        pushl   %ebp
+        movl    %esp, %ebp
+        subl    $8, %esp
+        andl    $-16, %esp
+        movl    $0, %eax
+        movl    %eax, -4(%ebp)
+        movl    -4(%ebp), %eax
+        call    __alloca
+        call    ___main
+        movl    $LC0, (%esp)
+        call    _printf
+        movl    $0, %eax
+        leave
+        ret
\ No newline at end of file
diff --git a/VS/CSHARP/asm-dude-vsix/Settings.Designer.cs b/VS/CSHARP/asm-dude-vsix/Settings.Designer.cs
index 59dccabf..65c0175f 100644
--- a/VS/CSHARP/asm-dude-vsix/Settings.Designer.cs
+++ b/VS/CSHARP/asm-dude-vsix/Settings.Designer.cs
@@ -1498,5 +1498,17 @@ public bool IntelliSense_Label_Analysis_On {
                 this["IntelliSense_Label_Analysis_On"] = value;
             }
         }
+        
+        [global::System.Configuration.UserScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.DefaultSettingValueAttribute("False")]
+        public bool useAssemblerNasm_Att {
+            get {
+                return ((bool)(this["useAssemblerNasm_Att"]));
+            }
+            set {
+                this["useAssemblerNasm_Att"] = value;
+            }
+        }
     }
 }
diff --git a/VS/CSHARP/asm-dude-vsix/Settings.settings b/VS/CSHARP/asm-dude-vsix/Settings.settings
index bd9a4ddc..f593bed0 100644
--- a/VS/CSHARP/asm-dude-vsix/Settings.settings
+++ b/VS/CSHARP/asm-dude-vsix/Settings.settings
@@ -371,5 +371,8 @@
     <Setting Name="IntelliSense_Label_Analysis_On" Type="System.Boolean" Scope="User">
       <Value Profile="(Default)">True</Value>
     </Setting>
+    <Setting Name="useAssemblerNasm_Att" Type="System.Boolean" Scope="User">
+      <Value Profile="(Default)">False</Value>
+    </Setting>
   </Settings>
 </SettingsFile>
\ No newline at end of file
diff --git a/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/AsmTokenTaggerProvider.cs b/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/AsmTokenTaggerProvider.cs
index af68e190..236556d3 100644
--- a/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/AsmTokenTaggerProvider.cs
+++ b/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/AsmTokenTaggerProvider.cs
@@ -45,7 +45,8 @@ public ITagger<T> CreateTagger<T>(ITextBuffer buffer) where T : ITag
             Func<ITagger<T>> sc = delegate ()
             {
                 if (AsmDudeToolsStatic.Used_Assembler.HasFlag(AssemblerEnum.MASM)) return new MasmTokenTagger(buffer) as ITagger<T>;
-                if (AsmDudeToolsStatic.Used_Assembler.HasFlag(AssemblerEnum.NASM)) return new NasmTokenTagger(buffer) as ITagger<T>;
+                if (AsmDudeToolsStatic.Used_Assembler.HasFlag(AssemblerEnum.NASM_INTEL)) return new NasmIntelTokenTagger(buffer) as ITagger<T>;
+                if (AsmDudeToolsStatic.Used_Assembler.HasFlag(AssemblerEnum.NASM_ATT)) return new NasmAttTokenTagger(buffer) as ITagger<T>;
                 return new MasmTokenTagger(buffer) as ITagger<T>;
             };
             return buffer.Properties.GetOrCreateSingletonProperty(sc);
diff --git a/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/DebugTokenTagger.cs b/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/DebugTokenTagger.cs
index d2c464a8..42dcc76d 100644
--- a/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/DebugTokenTagger.cs
+++ b/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/DebugTokenTagger.cs
@@ -73,7 +73,7 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                 foreach (var keywordInfo in AsmSourceTools.SplitIntoKeywordPos(line))
                 {
                     string asmToken = Keyword(keywordInfo, line);
-                    AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type(asmToken);
+                    AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type_Intel(asmToken);
                     if ((keywordType == AsmTokenType.Mnemonic) ||
                         (keywordType == AsmTokenType.Jump))
                     {
diff --git a/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/MasmTokenTagger.cs b/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/MasmTokenTagger.cs
index 631c1323..2f41a05f 100644
--- a/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/MasmTokenTagger.cs
+++ b/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/MasmTokenTagger.cs
@@ -100,18 +100,18 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
 
                 for (int k = 0; k < nKeywords; k++)
                 {
-                    string asmToken = NasmTokenTagger.Keyword(pos[k], line);
+                    string asmToken = NasmIntelTokenTagger.Keyword(pos[k], line);
                     // keyword starts with a remark char
                     if (AsmSourceTools.IsRemarkChar(asmToken[0]))
                     {
-                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._remark);
+                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._remark);
                         continue;
                     }
 
                     // keyword k is a label definition
                     if (pos[k].isLabel)
                     {
-                        SnapshotSpan labelDefSpan = NasmTokenTagger.New_Span(pos[k], offset, curSpan);
+                        SnapshotSpan labelDefSpan = NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan);
                         //AsmDudeToolsStatic.Output_INFO("MasmTokenTagger:GetTags: found label " + asmToken +" at line "+containingLine.LineNumber);
                         if (asmToken.Equals("@@"))
                         {
@@ -119,22 +119,23 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                         }
                         else
                         {
-                            yield return new TagSpan<AsmTokenTag>(labelDefSpan, Make_AsmTokenTag_LabelDef(containingLine.LineNumber));
+                            var v = Make_AsmTokenTag_LabelDef(containingLine.LineNumber);
+                            yield return new TagSpan<AsmTokenTag>(labelDefSpan, v);
                         }
                         continue;
                     }
 
-                    AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type(asmToken);
+                    AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type_Intel(asmToken);
                     switch (keywordType)
                     {
                         case AsmTokenType.Jump:
                             {
-                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._jump);
+                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._jump);
 
                                 k++; // goto the next word
                                 if (k == nKeywords) break;
 
-                                string asmToken2 = NasmTokenTagger.Keyword(pos[k], line);
+                                string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line);
                                 switch (asmToken2)
                                 {
                                     case "$":
@@ -150,11 +151,11 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                     case "SHORT":
                                     case "NEAR":
                                         {
-                                            yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._misc);
+                                            yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._misc);
 
                                             k++;
                                             if (k == nKeywords) break;
-                                            string asmToken3 = NasmTokenTagger.Keyword(pos[k], line);
+                                            string asmToken3 = NasmIntelTokenTagger.Keyword(pos[k], line);
                                             switch (asmToken3)
                                             {
                                                 case "$":
@@ -166,12 +167,12 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                                     }
                                                 case "PTR":
                                                     {
-                                                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._misc);
+                                                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._misc);
                                                         break;
                                                     }
                                                 default:
                                                     {
-                                                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
+                                                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
                                                         break;
                                                     }
                                             }
@@ -181,11 +182,11 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                         {
                                             if (RegisterTools.IsRegister(asmToken2))
                                             {
-                                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._register);
+                                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._register);
                                             }
                                             else
                                             {
-                                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
+                                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
                                             }
                                             break;
                                         }
@@ -196,13 +197,11 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                             {
                                 if (AsmTools.AsmSourceTools.IsConstant(asmToken))
                                 {
-                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
-
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
                                 }
                                 else if (asmToken.StartsWith("\"") && asmToken.EndsWith("\""))
                                 {
-                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
-
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
                                 }
                                 else
                                 {
@@ -212,22 +211,22 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                     if ((k + 1) < nKeywords)
                                     {
                                         k++;
-                                        string nextKeyword = NasmTokenTagger.Keyword(pos[k], line);
+                                        string nextKeyword = NasmIntelTokenTagger.Keyword(pos[k], line);
                                         switch (nextKeyword)
                                         {
                                             case "PROC":
                                             case "EQU":
                                             case "LABEL":
                                                 {
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef);
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
                                                     isUnknown = false;
                                                     break;
                                                 }
                                             case "PROTO":
                                                 { // a proto is considered a label definition but it should not clash with other label definitions
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef_PROTO);
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef_PROTO);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
                                                     isUnknown = false;
                                                     break;
                                                 }
@@ -242,18 +241,18 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                     // do one word look back; see whether we can understand the current unknown word
                                     if (k > 0)
                                     {
-                                        string previousKeyword = NasmTokenTagger.Keyword(pos[k - 1], line);
+                                        string previousKeyword = NasmIntelTokenTagger.Keyword(pos[k - 1], line);
                                         switch (previousKeyword)
                                         {
                                             case "ALIAS":
                                                 {
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef);
                                                     isUnknown = false;
                                                     break;
                                                 }
                                             case "INCLUDE":
                                                 {
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
                                                     isUnknown = false;
                                                     break;
                                                 }
@@ -266,7 +265,7 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
 
                                     if (isUnknown)
                                     {
-                                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._UNKNOWN);
+                                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._UNKNOWN);
                                     }
                                 }
                                 break;
@@ -276,23 +275,36 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                 AssemblerEnum assember = this._asmDudeTools.Get_Assembler(asmToken);
                                 if (assember.HasFlag(AssemblerEnum.MASM)) // this MASM token-tagger only tags MASM directives
                                 {
-                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
 
-                                    if (asmToken.Equals("INVOKE"))
+                                    switch (asmToken)
                                     {
-                                        k++; // goto the next word
-                                        if (k == nKeywords) break;
+                                        case "INVOKE":
+                                            {
+                                                k++; // goto the next word
+                                                if (k == nKeywords) break;
 
-                                        string asmToken2 = NasmTokenTagger.Keyword(pos[k], line);
-                                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
-                                        //yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._label); // do not use full qualified label!
+                                                string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line);
+                                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
+                                                break;
+                                            }
+                                        case "EXTRN":
+                                        case "EXTERN":
+                                            {
+                                                k++; // goto the next word
+                                                if (k == nKeywords) break;
+
+                                                string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line);
+                                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef_PROTO);
+                                                break;
+                                            }
                                     }
                                 }
-                                break;
                             }
+                            break;
                         default:
                             {
-                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), new AsmTokenTag(keywordType));
+                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), new AsmTokenTag(keywordType));
                                 break;
                             }
                     }
@@ -326,18 +338,18 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
 
                 while (hasNext)
                 {
-                    string asmToken = NasmTokenTagger.Keyword(current, line);
+                    string asmToken = NasmIntelTokenTagger.Keyword(current, line);
                     // keyword starts with a remark char
                     if (AsmSourceTools.IsRemarkChar(asmToken[0]))
                     {
-                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._remark);
+                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._remark);
                         continue;
                     }
 
                     // keyword k is a label definition
                     if (current.IsLabel)
                     {
-                        SnapshotSpan labelDefSpan = NasmTokenTagger.New_Span(current, offset, curSpan);
+                        SnapshotSpan labelDefSpan = NasmIntelTokenTagger.New_Span(current, offset, curSpan);
                         //AsmDudeToolsStatic.Output_INFO("MasmTokenTagger:GetTags: found label " + asmToken +" at line "+containingLine.LineNumber);
                         if (asmToken.Equals("@@"))
                         {
@@ -350,12 +362,12 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
                         continue;
                     }
 
-                    AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type(asmToken);
+                    AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type_Intel(asmToken);
                     switch (keywordType)
                     {
                         case AsmTokenType.Jump:
                             {
-                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._jump);
+                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._jump);
                                 {   // go to the next word
                                     if (needToAdvance)
                                     {
@@ -365,7 +377,7 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
                                     }
                                     needToAdvance = true;
                                 }
-                                string asmToken2 = NasmTokenTagger.Keyword(current, line);
+                                string asmToken2 = NasmIntelTokenTagger.Keyword(current, line);
                                 switch (asmToken2)
                                 {
                                     case "$":
@@ -381,7 +393,7 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
                                     case "SHORT":
                                     case "NEAR":
                                         {
-                                            yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._misc);
+                                            yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._misc);
                                             {   // go to the next word
                                                 if (needToAdvance)
                                                 {
@@ -391,7 +403,7 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
                                                 }
                                                 needToAdvance = true;
                                             }
-                                            switch (NasmTokenTagger.Keyword(current, line))
+                                            switch (NasmIntelTokenTagger.Keyword(current, line))
                                             {
                                                 case "$":
                                                 case "@B":
@@ -402,12 +414,12 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
                                                     }
                                                 case "PTR":
                                                     {
-                                                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._misc);
+                                                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._misc);
                                                         break;
                                                     }
                                                 default:
                                                     {
-                                                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
+                                                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
                                                         break;
                                                     }
                                             }
@@ -417,11 +429,11 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
                                         {
                                             if (RegisterTools.IsRegister(asmToken2))
                                             {
-                                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._register);
+                                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._register);
                                             }
                                             else
                                             {
-                                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
+                                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
                                             }
                                             break;
                                         }
@@ -432,21 +444,21 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
                             {
                                 if (AsmTools.AsmSourceTools.IsConstant(asmToken))
                                 {
-                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._constant);
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._constant);
                                 }
                                 else if (asmToken.StartsWith("\"") && asmToken.EndsWith("\""))
                                 {
-                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._constant);
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._constant);
                                 }
                                 else
                                 {
                                     // do one word look back; see whether we can understand the current unknown word
-                                    string previousKeyword = NasmTokenTagger.Keyword(prev, line);
+                                    string previousKeyword = NasmIntelTokenTagger.Keyword(prev, line);
                                     switch (previousKeyword)
                                     {
                                         case "ALIAS":
                                             {
-                                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._labelDef);
+                                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._labelDef);
                                                 break;
                                             }
                                         default:
@@ -464,21 +476,21 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
                                         prev = current;
                                         current = enumerator.Current;
 
-                                        string nextKeyword = NasmTokenTagger.Keyword(current, line);
+                                        string nextKeyword = NasmIntelTokenTagger.Keyword(current, line);
                                         switch (nextKeyword)
                                         {
                                             case "PROC":
                                             case "EQU":
                                             case "LABEL":
                                                 {
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(prev, offset, curSpan), this._labelDef);
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._directive);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(prev, offset, curSpan), this._labelDef);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._directive);
                                                     break;
                                                 }
                                             case "PROTO":
                                                 { // a proto is considered a label definition but it should not clash with other label definitions
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(prev, offset, curSpan), this._labelDef_PROTO);
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._directive);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(prev, offset, curSpan), this._labelDef_PROTO);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._directive);
                                                     break;
                                                 }
                                             default:
@@ -487,7 +499,7 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
                                     }
                                     else
                                     {
-                                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._UNKNOWN);
+                                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._UNKNOWN);
                                     }
                                 }
                                 break;
@@ -497,7 +509,7 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
                                 AssemblerEnum assember = this._asmDudeTools.Get_Assembler(asmToken);
                                 if (assember.HasFlag(AssemblerEnum.MASM)) // this MASM token-tagger only tags MASM directives
                                 {
-                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), this._directive);
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this._directive);
 
                                     if (asmToken.Equals("INVOKE"))
                                     {
@@ -511,14 +523,14 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags_NEW(NormalizedSnapshotSpanColl
                                             needToAdvance = true;
                                         }
                                         //string asmToken2 = NasmTokenTagger.Keyword(current, line);
-                                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
+                                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber));
                                     }
                                 }
                                 break;
                             }
                         default:
                             {
-                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(current, offset, curSpan), new AsmTokenTag(keywordType));
+                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), new AsmTokenTag(keywordType));
                                 break;
                             }
                     }
@@ -559,16 +571,13 @@ private string Get_Procedure_Name(int lineNumber)
             for (int i = lineNumber; i >= 0; --i)
             {
                 string line = this._buffer.CurrentSnapshot.GetLineFromLineNumber(i).GetText();
-                var positions = AsmSourceTools.SplitIntoKeywordPos(line).GetEnumerator();
-
-                var pos0 = positions.Current;
-                if (positions.MoveNext())
+                IList<(int, int, bool)> positions = new List<(int, int, bool)>(AsmSourceTools.SplitIntoKeywordPos(line));
+                if (positions.Count > 1)
                 {
-                    var pos1 = positions.Current;
-                    string keywordStr = NasmTokenTagger.Keyword(pos1, line).ToUpper();
+                    string keywordStr = NasmIntelTokenTagger.Keyword(positions[1], line).ToUpper();
                     switch (keywordStr)
                     {
-                        case "PROC": return NasmTokenTagger.Keyword(pos0, line);
+                        case "PROC": return NasmIntelTokenTagger.Keyword(positions[0], line);
                         case "ENDP": return null;
                         default: break;
                     }
diff --git a/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/NasmAttTokenTagger.cs b/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/NasmAttTokenTagger.cs
new file mode 100644
index 00000000..21ccf84b
--- /dev/null
+++ b/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/NasmAttTokenTagger.cs
@@ -0,0 +1,434 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Henk-Jan Lebbink
+// 
+// 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.
+
+using System;
+using System.Collections.Generic;
+
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Tagging;
+
+using AsmDude.SyntaxHighlighting;
+using AsmDude.Tools;
+using AsmTools;
+
+namespace AsmDude
+{
+    internal sealed class NasmAttTokenTagger : ITagger<AsmTokenTag>
+    {
+        private readonly ITextBuffer _buffer;
+        private readonly AsmDudeTools _asmDudeTools = null;
+
+        private readonly AsmTokenTag _mnemonic;
+        private readonly AsmTokenTag _register;
+        private readonly AsmTokenTag _remark;
+        private readonly AsmTokenTag _directive;
+        private readonly AsmTokenTag _constant;
+        private readonly AsmTokenTag _jump;
+        private readonly AsmTokenTag _label;
+        private readonly AsmTokenTag _labelDef;
+        private readonly AsmTokenTag _misc;
+        private readonly AsmTokenTag _userDefined1;
+        private readonly AsmTokenTag _userDefined2;
+        private readonly AsmTokenTag _userDefined3;
+        private readonly AsmTokenTag _UNKNOWN;
+
+        internal NasmAttTokenTagger(ITextBuffer buffer)
+        {
+            this._buffer = buffer;
+            this._asmDudeTools = AsmDudeTools.Instance;
+
+            this._mnemonic = new AsmTokenTag(AsmTokenType.Mnemonic);
+            this._register = new AsmTokenTag(AsmTokenType.Register);
+            this._remark = new AsmTokenTag(AsmTokenType.Remark);
+            this._directive = new AsmTokenTag(AsmTokenType.Directive);
+            this._constant = new AsmTokenTag(AsmTokenType.Constant);
+            this._jump = new AsmTokenTag(AsmTokenType.Jump);
+            this._label = new AsmTokenTag(AsmTokenType.Label);
+            this._labelDef = new AsmTokenTag(AsmTokenType.LabelDef);
+            this._misc = new AsmTokenTag(AsmTokenType.Misc);
+            this._userDefined1 = new AsmTokenTag(AsmTokenType.UserDefined1);
+            this._userDefined2 = new AsmTokenTag(AsmTokenType.UserDefined2);
+            this._userDefined3 = new AsmTokenTag(AsmTokenType.UserDefined3);
+            this._UNKNOWN = new AsmTokenTag(AsmTokenType.UNKNOWN);
+        }
+
+        event EventHandler<SnapshotSpanEventArgs> ITagger<AsmTokenTag>.TagsChanged
+        {
+            add { }
+            remove { }
+        }
+
+        public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollection spans)
+        {
+            DateTime time1 = DateTime.Now;
+
+            if (spans.Count == 0)
+            {  //there is no content in the buffer
+                yield break;
+            }
+
+            foreach (SnapshotSpan curSpan in spans)
+            {
+                ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
+
+                string line = containingLine.GetText().ToUpper();
+                IList<(int beginPos, int length, bool isLabel)> pos = new List<(int beginPos, int length, bool isLabel)>(AsmSourceTools.SplitIntoKeywordPos(line));
+
+                int offset = containingLine.Start.Position;
+                int nKeywords = pos.Count;
+
+                for (int k = 0; k < nKeywords; k++)
+                {
+                    string asmToken = NasmIntelTokenTagger.Keyword(pos[k], line);
+                    // keyword starts with a remark char
+                    if (AsmSourceTools.IsRemarkChar(asmToken[0]))
+                    {
+                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._remark);
+                        continue;
+                    }
+
+                    // keyword k is a label definition
+                    if (pos[k].isLabel)
+                    {
+                        //AsmDudeToolsStatic.Output_INFO("NasmTokenTagger:GetTags: found label " +asmToken);
+                        if (IsProperLabelDef(asmToken, containingLine.LineNumber, out AsmTokenTag asmTokenTag))
+                        {
+                            yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), asmTokenTag);
+                            continue;
+                        }
+                    }
+
+                    AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type_Att(asmToken);
+                    switch (keywordType)
+                    {
+                        case AsmTokenType.Jump:
+                            {
+                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._jump);
+
+                                k++; // goto the next word
+                                if (k == nKeywords) break; // there are no next words
+
+                                string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line);
+                                switch (asmToken2)
+                                {
+                                    case "WORD":
+                                    case "DWORD":
+                                    case "QWORD":
+                                    case "SHORT":
+                                    case "NEAR":
+                                        {
+                                            yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._misc);
+
+                                            k++;
+                                            if (k == nKeywords) break;
+                                            string asmToken3 = NasmIntelTokenTagger.Keyword(pos[k], line);
+                                            if (asmToken3.Equals("PTR"))
+                                            {
+                                                yield return new TagSpan<AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._misc);
+                                            }
+                                            else
+                                            {
+                                                if (IsProperLabel(asmToken3, containingLine.LineNumber, out AsmTokenTag asmTokenTag))
+                                                {
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), asmTokenTag);
+                                                }
+                                            }
+                                            break;
+                                        }
+                                    default:
+                                        {
+                                            if (RegisterTools.IsRegister(asmToken2, true))
+                                            {
+                                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._register);
+                                            }
+                                            else
+                                            {
+                                                if (IsProperLabel(asmToken2, containingLine.LineNumber, out AsmTokenTag asmTokenTag))
+                                                {
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), asmTokenTag);
+                                                }
+                                            }
+                                            break;
+                                        }
+                                }
+                                break;
+                            }
+                        case AsmTokenType.UNKNOWN: // asmToken is not a known keyword, check if it is numerical
+                            {
+                                if (AsmTools.AsmSourceTools.IsConstant(asmToken))
+                                {
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
+
+                                }
+                                else if (asmToken.StartsWith("\"") && asmToken.EndsWith("\""))
+                                {
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
+
+                                }
+                                else
+                                {
+                                    bool isUnknown = true;
+
+                                    // do one word lookahead; see whether we can understand the current unknown word
+                                    if ((k + 1) < nKeywords)
+                                    {
+                                        k++;
+                                        string nextKeyword = NasmIntelTokenTagger.Keyword(pos[k], line);
+                                        switch (nextKeyword)
+                                        {
+                                            case "LABEL":
+                                                {
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
+                                                    isUnknown = false;
+                                                    break;
+                                                }
+                                            default:
+                                                {
+                                                    k--;
+                                                    break;
+                                                }
+                                        }
+                                    }
+
+                                    // do one word look back; see whether we can understand the current unknown word
+                                    if (k > 0)
+                                    {
+                                        string previousKeyword = NasmIntelTokenTagger.Keyword(pos[k - 1], line);
+                                        switch (previousKeyword)
+                                        {
+                                            case "ALIAS":
+                                                {
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef);
+                                                    isUnknown = false;
+                                                    break;
+                                                }
+                                            case "INCLUDE":
+                                                {
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
+                                                    isUnknown = false;
+                                                    break;
+                                                }
+                                            default:
+                                                {
+                                                    break;
+                                                }
+                                        }
+                                    }
+                                    if (isUnknown)
+                                    {
+                                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._UNKNOWN);
+                                    }
+                                }
+                                break;
+                            }
+                        case AsmTokenType.Directive:
+                            {
+                                AssemblerEnum assember = this._asmDudeTools.Get_Assembler(asmToken);
+                                if (assember.HasFlag(AssemblerEnum.NASM_INTEL) || assember.HasFlag(AssemblerEnum.NASM_ATT))
+                                {
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
+                                }
+                                break;
+                            }
+                        default:
+                            {
+                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), new AsmTokenTag(keywordType));
+                                break;
+                            }
+                    }
+                }
+            }
+            AsmDudeToolsStatic.Print_Speed_Warning(time1, "AttTokenTagger");
+        }
+
+        #region Public Static Methods
+
+        public static bool Advance(
+            ref int tokenId,
+            ref int curLoc,
+            ref int nextLoc,
+            out string asmToken,
+            out SnapshotSpan? asmTokenSpan,
+            string[] tokens,
+            SnapshotSpan curSpan)
+        {
+            var tup = Get_Next_Token(tokenId, nextLoc, tokens);
+            tokenId = tup.Item2;
+            nextLoc = tup.Item3;
+
+            if (tup.Item1)
+            {
+                asmToken = tup.Item4;
+                curLoc = nextLoc - (asmToken.Length + 1);
+
+                asmTokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(curLoc, asmToken.Length));
+                //if (asmTokenSpan.Value.IntersectsWith(curSpan)) {
+                return true;
+                //TODO find out what it means if not asmTokenSpan.Value.IntersectsWith(curSpan)
+                //}
+            }
+            else
+            {
+                asmToken = null;
+                asmTokenSpan = null;
+                return false;
+            }
+        }
+
+        // return true, nextTokenId, tokenEndPos, tokenString
+        public static (bool, int, int, string) Get_Next_Token(int tokenId, int startLoc, string[] tokens)
+        {
+            int nextTokenId = tokenId;
+            int nextLoc = startLoc;
+
+            while (nextTokenId < tokens.Length)
+            {
+                string asmToken = tokens[nextTokenId];
+                nextTokenId++;
+                if (asmToken.Length > 0)
+                {
+                    nextLoc += asmToken.Length + 1; //add an extra char location because of the separator
+                    return (true, nextTokenId, nextLoc, asmToken.ToUpper());
+                }
+                else
+                {
+                    nextLoc++;
+                }
+            }
+            return (false, nextTokenId, nextLoc, "");
+        }
+
+        public static string Keyword((int, int, bool) pos, string line)
+        {
+            return line.Substring(pos.Item1, pos.Item2 - pos.Item1);
+        }
+
+        public static SnapshotSpan New_Span((int, int, bool) pos, int offset, SnapshotSpan lineSnapShot)
+        {
+            return new SnapshotSpan(lineSnapShot.Snapshot, new Span(pos.Item1 + offset, pos.Item2 - pos.Item1));
+        }
+        #endregion Public Static Methods
+
+        #region Private Member Methods
+
+        private bool IsProperLabelDef(string asmToken, int lineNumber, out AsmTokenTag labelDefSpan)
+        {
+            labelDefSpan = null;
+            if (!IsExecutableCode(lineNumber)) return false;
+
+            if (asmToken.StartsWith("."))
+            {
+                if (Get_Last_Non_Local_Label(lineNumber, out string lastNonLocalLabel))
+                {
+                    labelDefSpan = new AsmTokenTag(AsmTokenType.LabelDef, lastNonLocalLabel);
+                    return true;
+                }
+            }
+            else
+            {
+                labelDefSpan = this._labelDef;
+                return true;
+            }
+            return false;
+        }
+
+        private bool IsProperLabel(string asmToken, int lineNumber, out AsmTokenTag labelSpan)
+        {
+            labelSpan = null;
+
+            //AsmDudeToolsStatic.Output_INFO("NasmTokenTagger:GetTags: found label " +asmToken);
+            if (asmToken.StartsWith("."))
+            {
+                if (Get_Last_Non_Local_Label(lineNumber, out string lastNonLocalLabel))
+                {
+                    labelSpan = new AsmTokenTag(AsmTokenType.Label, lastNonLocalLabel);
+                    return true;
+                }
+            }
+            else
+            {
+                labelSpan = this._label;
+                return true;
+            }
+            labelSpan = null;
+            return false;
+        }
+
+        private bool IsExecutableCode(int lineNumber)
+        {
+            for (int i = lineNumber - 1; i >= 0; --i)
+            {
+                string line = this._buffer.CurrentSnapshot.GetLineFromLineNumber(i).GetText();
+                IList<(int, int, bool)> pos = new List<(int, int, bool)>(AsmSourceTools.SplitIntoKeywordPos(line));
+                if ((pos.Count > 0) && !pos[0].Item3)
+                {
+                    string keywordString = NasmIntelTokenTagger.Keyword(pos[0], line).ToUpper();
+                    if (AsmSourceTools.ParseMnemonic(keywordString) != Mnemonic.UNKNOWN)
+                    {
+                        return true;
+                    }
+                    switch (keywordString)
+                    {
+                        case "STRUC": return false;
+                        case "ENDSTRUC": return true;
+                    }
+                }
+                if ((pos.Count > 1) && !pos[1].Item3)
+                {
+                    string keywordString = NasmIntelTokenTagger.Keyword(pos[1], line).ToUpper();
+                    if (AsmSourceTools.ParseMnemonic(keywordString) != Mnemonic.UNKNOWN)
+                    {
+                        return true;
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool Get_Last_Non_Local_Label(int lineNumber, out string lastNonLocalLabel)
+        {
+            //AsmDudeToolsStatic.Output_INFO("NasmTokenTagger:get_Last_Non_Local_Label: lineNumber=" + lineNumber);
+            lastNonLocalLabel = null;
+
+            for (int i = lineNumber - 1; i >= 0; --i)
+            {
+                string line = this._buffer.CurrentSnapshot.GetLineFromLineNumber(i).GetText();
+                (int, int, bool) pos = AsmSourceTools.Get_First_Keyword(line);
+                string keywordString = NasmIntelTokenTagger.Keyword(pos, line);
+
+                if (pos.Item3)
+                {
+                    if (!keywordString[0].Equals('.'))
+                    {
+                        //AsmDudeToolsStatic.Output_INFO("NasmTokenTagger:Get_Last_Non_Local_Label: found label \"" + keywordString + "\" at lineNumber " + i + "; beginPos=" + pos.Item1 + "; endPos=" + pos.Item2);
+                        lastNonLocalLabel = keywordString;
+                        return true;
+                    }
+                }
+            }
+            //AsmDudeToolsStatic.Output_INFO("NasmTokenTagger:get_Last_Non_Local_Label: could not find regular label before lineNumber " + lineNumber);
+            return false;
+        }
+        #endregion
+    }
+}
diff --git a/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/NasmTokenTagger.cs b/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/NasmIntelTokenTagger.cs
similarity index 86%
rename from VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/NasmTokenTagger.cs
rename to VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/NasmIntelTokenTagger.cs
index f23dbe55..6fe4f844 100644
--- a/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/NasmTokenTagger.cs
+++ b/VS/CSHARP/asm-dude-vsix/SyntaxHighlighting/NasmIntelTokenTagger.cs
@@ -32,7 +32,7 @@
 
 namespace AsmDude
 {
-    internal sealed class NasmTokenTagger : ITagger<AsmTokenTag>
+    internal sealed class NasmIntelTokenTagger : ITagger<AsmTokenTag>
     {
         private readonly ITextBuffer _buffer;
         private readonly AsmDudeTools _asmDudeTools = null;
@@ -46,9 +46,12 @@ internal sealed class NasmTokenTagger : ITagger<AsmTokenTag>
         private readonly AsmTokenTag _label;
         private readonly AsmTokenTag _labelDef;
         private readonly AsmTokenTag _misc;
+        private readonly AsmTokenTag _userDefined1;
+        private readonly AsmTokenTag _userDefined2;
+        private readonly AsmTokenTag _userDefined3;
         private readonly AsmTokenTag _UNKNOWN;
 
-        internal NasmTokenTagger(ITextBuffer buffer)
+        internal NasmIntelTokenTagger(ITextBuffer buffer)
         {
             this._buffer = buffer;
             this._asmDudeTools = AsmDudeTools.Instance;
@@ -62,6 +65,9 @@ internal NasmTokenTagger(ITextBuffer buffer)
             this._label = new AsmTokenTag(AsmTokenType.Label);
             this._labelDef = new AsmTokenTag(AsmTokenType.LabelDef);
             this._misc = new AsmTokenTag(AsmTokenType.Misc);
+            this._userDefined1 = new AsmTokenTag(AsmTokenType.UserDefined1);
+            this._userDefined2 = new AsmTokenTag(AsmTokenType.UserDefined2);
+            this._userDefined3 = new AsmTokenTag(AsmTokenType.UserDefined3);
             this._UNKNOWN = new AsmTokenTag(AsmTokenType.UNKNOWN);
         }
 
@@ -85,43 +91,42 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                 ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
 
                 string line = containingLine.GetText().ToUpper();
-                IList<(int, int, bool)> pos = new List<(int, int, bool)>(AsmSourceTools.SplitIntoKeywordPos(line));
+                IList<(int beginPos, int length, bool isLabel)> pos = new List<(int beginPos, int length, bool isLabel)>(AsmSourceTools.SplitIntoKeywordPos(line));
 
                 int offset = containingLine.Start.Position;
                 int nKeywords = pos.Count;
 
                 for (int k = 0; k < nKeywords; k++)
                 {
-                    string asmToken = NasmTokenTagger.Keyword(pos[k], line);
+                    string asmToken = NasmIntelTokenTagger.Keyword(pos[k], line);
                     // keyword starts with a remark char
                     if (AsmSourceTools.IsRemarkChar(asmToken[0]))
                     {
-                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._remark);
+                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._remark);
                         continue;
                     }
 
                     // keyword k is a label definition
-                    if (pos[k].Item3)
+                    if (pos[k].isLabel)
                     {
                         //AsmDudeToolsStatic.Output_INFO("NasmTokenTagger:GetTags: found label " +asmToken);
                         if (IsProperLabelDef(asmToken, containingLine.LineNumber, out AsmTokenTag asmTokenTag))
                         {
-                            yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), asmTokenTag);
+                            yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), asmTokenTag);
                             continue;
                         }
                     }
-
-                    AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type(asmToken);
+                    AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type_Intel(asmToken);
                     switch (keywordType)
                     {
                         case AsmTokenType.Jump:
                             {
-                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._jump);
+                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._jump);
 
                                 k++; // goto the next word
                                 if (k == nKeywords) break; // there are no next words
 
-                                string asmToken2 = NasmTokenTagger.Keyword(pos[k], line);
+                                string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line);
                                 switch (asmToken2)
                                 {
                                     case "WORD":
@@ -130,11 +135,11 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                     case "SHORT":
                                     case "NEAR":
                                         {
-                                            yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._misc);
+                                            yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._misc);
 
                                             k++;
                                             if (k == nKeywords) break;
-                                            string asmToken3 = NasmTokenTagger.Keyword(pos[k], line);
+                                            string asmToken3 = NasmIntelTokenTagger.Keyword(pos[k], line);
                                             if (asmToken3.Equals("PTR"))
                                             {
                                                 yield return new TagSpan<AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._misc);
@@ -143,7 +148,7 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                             {
                                                 if (IsProperLabel(asmToken3, containingLine.LineNumber, out AsmTokenTag asmTokenTag))
                                                 {
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), asmTokenTag);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), asmTokenTag);
                                                 }
                                             }
                                             break;
@@ -152,13 +157,13 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                         {
                                             if (RegisterTools.IsRegister(asmToken2, true))
                                             {
-                                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._register);
+                                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._register);
                                             }
                                             else
                                             {
                                                 if (IsProperLabel(asmToken2, containingLine.LineNumber, out AsmTokenTag asmTokenTag))
                                                 {
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), asmTokenTag);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), asmTokenTag);
                                                 }
                                             }
                                             break;
@@ -170,12 +175,12 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                             {
                                 if (AsmTools.AsmSourceTools.IsConstant(asmToken))
                                 {
-                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
 
                                 }
                                 else if (asmToken.StartsWith("\"") && asmToken.EndsWith("\""))
                                 {
-                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
 
                                 }
                                 else
@@ -186,13 +191,13 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                     if ((k + 1) < nKeywords)
                                     {
                                         k++;
-                                        string nextKeyword = NasmTokenTagger.Keyword(pos[k], line);
+                                        string nextKeyword = NasmIntelTokenTagger.Keyword(pos[k], line);
                                         switch (nextKeyword)
                                         {
                                             case "LABEL":
                                                 {
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef);
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
                                                     isUnknown = false;
                                                     break;
                                                 }
@@ -207,18 +212,18 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                     // do one word look back; see whether we can understand the current unknown word
                                     if (k > 0)
                                     {
-                                        string previousKeyword = NasmTokenTagger.Keyword(pos[k - 1], line);
+                                        string previousKeyword = NasmIntelTokenTagger.Keyword(pos[k - 1], line);
                                         switch (previousKeyword)
                                         {
                                             case "ALIAS":
                                                 {
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef);
                                                     isUnknown = false;
                                                     break;
                                                 }
                                             case "INCLUDE":
                                                 {
-                                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
+                                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant);
                                                     isUnknown = false;
                                                     break;
                                                 }
@@ -230,7 +235,7 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                                     }
                                     if (isUnknown)
                                     {
-                                        yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._UNKNOWN);
+                                        yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._UNKNOWN);
                                     }
                                 }
                                 break;
@@ -238,15 +243,15 @@ public IEnumerable<ITagSpan<AsmTokenTag>> GetTags(NormalizedSnapshotSpanCollecti
                         case AsmTokenType.Directive:
                             {
                                 AssemblerEnum assember = this._asmDudeTools.Get_Assembler(asmToken);
-                                if (assember.HasFlag(AssemblerEnum.NASM)) // this NASM token-tagger only tags NASM directives
+                                if (assember.HasFlag(AssemblerEnum.NASM_INTEL) || assember.HasFlag(AssemblerEnum.NASM_ATT))
                                 {
-                                    yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
-                                }
+                                    yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive);
+								}
                                 break;
                             }
                         default:
                             {
-                                yield return new TagSpan<AsmTokenTag>(NasmTokenTagger.New_Span(pos[k], offset, curSpan), new AsmTokenTag(keywordType));
+                                yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), new AsmTokenTag(keywordType));
                                 break;
                             }
                     }
@@ -376,7 +381,7 @@ private bool IsExecutableCode(int lineNumber)
                 IList<(int, int, bool)> pos = new List<(int, int, bool)>(AsmSourceTools.SplitIntoKeywordPos(line));
                 if ((pos.Count > 0) && !pos[0].Item3)
                 {
-                    string keywordString = NasmTokenTagger.Keyword(pos[0], line).ToUpper();
+                    string keywordString = NasmIntelTokenTagger.Keyword(pos[0], line).ToUpper();
                     if (AsmSourceTools.ParseMnemonic(keywordString) != Mnemonic.UNKNOWN)
                     {
                         return true;
@@ -389,7 +394,7 @@ private bool IsExecutableCode(int lineNumber)
                 }
                 if ((pos.Count > 1) && !pos[1].Item3)
                 {
-                    string keywordString = NasmTokenTagger.Keyword(pos[1], line).ToUpper();
+                    string keywordString = NasmIntelTokenTagger.Keyword(pos[1], line).ToUpper();
                     if (AsmSourceTools.ParseMnemonic(keywordString) != Mnemonic.UNKNOWN)
                     {
                         return true;
@@ -408,7 +413,7 @@ private bool Get_Last_Non_Local_Label(int lineNumber, out string lastNonLocalLab
             {
                 string line = this._buffer.CurrentSnapshot.GetLineFromLineNumber(i).GetText();
                 (int, int, bool) pos = AsmSourceTools.Get_First_Keyword(line);
-                string keywordString = NasmTokenTagger.Keyword(pos, line);
+                string keywordString = NasmIntelTokenTagger.Keyword(pos, line);
 
                 if (pos.Item3)
                 {
diff --git a/VS/CSHARP/asm-dude-vsix/Tools/AsmDudeTools.cs b/VS/CSHARP/asm-dude-vsix/Tools/AsmDudeTools.cs
index b31fa33b..05a20d18 100644
--- a/VS/CSHARP/asm-dude-vsix/Tools/AsmDudeTools.cs
+++ b/VS/CSHARP/asm-dude-vsix/Tools/AsmDudeTools.cs
@@ -272,7 +272,42 @@ public IEnumerable<string> Get_Keywords()
             return this._type.Keys;
         }
 
-        public AsmTokenType Get_Token_Type(string keyword)
+        public AsmTokenType Get_Token_Type_Att(string keyword)
+        {
+            Debug.Assert(keyword == keyword.ToUpper());
+            int length = keyword.Length;
+            Debug.Assert(length > 0);
+
+            char firstChar = keyword[0];
+
+            #region Test if keyword is a register
+            if (firstChar == '%')
+            {
+                string keyword2 = keyword.Substring(1);
+                Rn reg = RegisterTools.ParseRn(keyword2, true);
+                return (reg != Rn.NOREG) ? AsmTokenType.Register : AsmTokenType.UNKNOWN;
+            }
+            #endregion
+            #region Test if keyword is an imm
+            if (firstChar == '$')
+            {
+                return AsmTokenType.Constant;
+            }
+            #endregion
+            #region Test if keyword is an instruction
+            {
+                Mnemonic mnemonic = AsmSourceTools.ParseMnemonic_Att(keyword, true);
+                if (mnemonic != Mnemonic.UNKNOWN)
+                {
+                    return (AsmSourceTools.IsJump(mnemonic)) ? AsmTokenType.Jump : AsmTokenType.Mnemonic;
+                }
+            }
+            #endregion
+
+            return (this._type.TryGetValue(keyword, out var tokenType)) ? tokenType : AsmTokenType.UNKNOWN;
+        }
+
+        public AsmTokenType Get_Token_Type_Intel(string keyword)
         {
             Debug.Assert(keyword == keyword.ToUpper());
 
diff --git a/VS/CSHARP/asm-dude-vsix/Tools/AsmDudeToolsStatic.cs b/VS/CSHARP/asm-dude-vsix/Tools/AsmDudeToolsStatic.cs
index c4ea8131..3f2a9085 100644
--- a/VS/CSHARP/asm-dude-vsix/Tools/AsmDudeToolsStatic.cs
+++ b/VS/CSHARP/asm-dude-vsix/Tools/AsmDudeToolsStatic.cs
@@ -86,14 +86,9 @@ public static AssemblerEnum Used_Assembler
         {
             get
             {
-                if (Settings.Default.useAssemblerMasm)
-                {
-                    return AssemblerEnum.MASM;
-                }
-                if (Settings.Default.useAssemblerNasm)
-                {
-                    return AssemblerEnum.NASM;
-                }
+                if (Settings.Default.useAssemblerMasm) return AssemblerEnum.MASM;
+                if (Settings.Default.useAssemblerNasm) return AssemblerEnum.NASM_INTEL;
+                if (Settings.Default.useAssemblerNasm_Att) return AssemblerEnum.NASM_ATT;
                 Output("WARNING: AsmDudeToolsStatic.usedAssebler: no assembler specified, assuming MASM");
                 return AssemblerEnum.MASM;
             }
@@ -101,15 +96,20 @@ public static AssemblerEnum Used_Assembler
             {
                 Settings.Default.useAssemblerMasm = false;
                 Settings.Default.useAssemblerNasm = false;
+                Settings.Default.useAssemblerNasm_Att = false;
 
                 if (value.HasFlag(AssemblerEnum.MASM))
                 {
                     Settings.Default.useAssemblerMasm = true;
                 }
-                else if (value.HasFlag(AssemblerEnum.NASM))
+                else if (value.HasFlag(AssemblerEnum.NASM_INTEL))
                 {
                     Settings.Default.useAssemblerNasm = true;
                 }
+                else if (value.HasFlag(AssemblerEnum.NASM_ATT))
+                {
+                    Settings.Default.useAssemblerNasm_Att = true;
+                }
                 else
                 {
                     Settings.Default.useAssemblerMasm = true;
@@ -638,7 +638,7 @@ public static string Make_Full_Qualified_Label(string prefix, string label2, Ass
                     return label2;
                 }
             }
-            else if (assembler.HasFlag(AssemblerEnum.NASM))
+            else if (assembler.HasFlag(AssemblerEnum.NASM_INTEL))
             {
                 if ((prefix != null) && (prefix.Length > 0))
                 {
@@ -668,7 +668,7 @@ public static string Retrieve_Regular_Label(string label, AssemblerEnum assemble
                     }
                 }
             }
-            else if (assembler.HasFlag(AssemblerEnum.NASM))
+            else if (assembler.HasFlag(AssemblerEnum.NASM_INTEL))
             {
                 for (int i = 0; i < label.Length; ++i)
                 {
diff --git a/VS/CSHARP/asm-dude-vsix/VsPackage.resx b/VS/CSHARP/asm-dude-vsix/VsPackage.resx
index 25c12a5b..4d2cbec2 100644
--- a/VS/CSHARP/asm-dude-vsix/VsPackage.resx
+++ b/VS/CSHARP/asm-dude-vsix/VsPackage.resx
@@ -121,7 +121,7 @@
     <value>AsmDude</value>
   </data>
   <data name="112" xml:space="preserve">
-    <value>Syntax highlighting, code completion and code folding for assembly (.asm, .cod, .inc) source code.</value>
+    <value>Syntax highlighting, code completion and code folding for assembly (.asm, .cod, .inc, .s) source code.</value>
   </data>
   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
   <data name="400" type="System.Resources.ResXFileRef, System.Windows.Forms">
diff --git a/VS/CSHARP/asm-dude-vsix/app.config b/VS/CSHARP/asm-dude-vsix/app.config
index 1f573bf0..79cf3216 100644
--- a/VS/CSHARP/asm-dude-vsix/app.config
+++ b/VS/CSHARP/asm-dude-vsix/app.config
@@ -376,6 +376,9 @@
    <setting name="IntelliSense_Label_Analysis_On" serializeAs="String">
     <value>True</value>
    </setting>
+   <setting name="useAssemblerNasm_Att" serializeAs="String">
+    <value>False</value>
+   </setting>
   </AsmDude.Settings>
 	</userSettings>
 	<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1"/></startup></configuration>
diff --git a/VS/CSHARP/asm-dude-vsix/asm-dude-vsix.csproj b/VS/CSHARP/asm-dude-vsix/asm-dude-vsix.csproj
index b20e940a..c8449a60 100644
--- a/VS/CSHARP/asm-dude-vsix/asm-dude-vsix.csproj
+++ b/VS/CSHARP/asm-dude-vsix/asm-dude-vsix.csproj
@@ -193,6 +193,7 @@
     <Compile Include="AsmDoc\AsmDocUnderlineTagger.cs" />
     <Compile Include="AsmDoc\AsmDocUnderlineTaggerProvider.cs" />
     <Compile Include="AsmDudePackage.cs" />
+    <Compile Include="SyntaxHighlighting\NasmAttTokenTagger.cs" />
     <Compile Include="Tools\AsmSimulator.cs" />
     <Compile Include="BraceMatching\BraceMatchingTagger.cs" />
     <Compile Include="BraceMatching\BraceMatchingTaggerProvider.cs" />
@@ -244,7 +245,7 @@
     <Compile Include="SyntaxHighlighting\AsmClassificationFormat.cs" />
     <Compile Include="SyntaxHighlighting\DebugTokenTagger.cs" />
     <Compile Include="SyntaxHighlighting\MasmTokenTagger.cs" />
-    <Compile Include="SyntaxHighlighting\NasmTokenTagger.cs" />
+    <Compile Include="SyntaxHighlighting\NasmIntelTokenTagger.cs" />
     <Compile Include="Tools\ApplicationInformation.cs" />
     <Compile Include="Tools\AsmDudeTools.cs" />
     <Compile Include="Tools\AsmDudeToolsStatic.cs" />
diff --git a/VS/CSHARP/asm-tools-lib/AssemblerEnum.cs b/VS/CSHARP/asm-tools-lib/AssemblerEnum.cs
index 30c09182..1f09e10e 100644
--- a/VS/CSHARP/asm-tools-lib/AssemblerEnum.cs
+++ b/VS/CSHARP/asm-tools-lib/AssemblerEnum.cs
@@ -27,9 +27,10 @@ namespace AsmTools {
     [Flags]
     public enum AssemblerEnum : byte {
         UNKNOWN = 0,
-        NASM    = 1 << 0,
-        MASM    = 1 << 1,
-        ALL     = NASM | MASM
+        MASM = 1 << 0,
+        NASM_INTEL = 1 << 1,
+        NASM_ATT = 1 << 2,
+        ALL = NASM_INTEL | NASM_ATT | MASM
     }
 
     public static partial class AsmSourceTools {
@@ -44,7 +45,7 @@ public static AssemblerEnum ParseAssembler(string str) {
                 switch (str2.Trim())
                 {
                     case "MASM": result |= AssemblerEnum.MASM; break;
-                    case "NASM": result |= AssemblerEnum.NASM; break;
+                    case "NASM": result |= AssemblerEnum.NASM_INTEL; break;
                 }
             }
             return result;
diff --git a/VS/CSHARP/asm-tools-lib/Mnemonic.cs b/VS/CSHARP/asm-tools-lib/Mnemonic.cs
index 90f88504..f6a47421 100644
--- a/VS/CSHARP/asm-tools-lib/Mnemonic.cs
+++ b/VS/CSHARP/asm-tools-lib/Mnemonic.cs
@@ -2294,6 +2294,32 @@ public static bool IsJump(Mnemonic mnemonic) {
             }
         }
 
+        public static Mnemonic ParseMnemonic_Att(string str, bool strIsCapitals = false)
+        {
+            string str2 = (strIsCapitals) ? str : str.ToUpper();
+
+            Mnemonic r = ParseMnemonic(str2, true);
+            if (r != Mnemonic.UNKNOWN) return r;
+            int length = str2.Length;
+
+            bool suffix;
+            switch (str[length - 1])
+            {
+                case 'B':
+                case 'S':
+                case 'W':
+                case 'L':
+                case 'Q':
+                case 'T': suffix = true; break;
+                default: suffix = false; break;
+            }
+            if (suffix)
+            {
+                string keyword2 = str.Substring(0, length - 1);
+                return AsmSourceTools.ParseMnemonic(keyword2, true);
+            }
+            return Mnemonic.UNKNOWN;
+        }
         public static Mnemonic ParseMnemonic(string str, bool strIsCapitals = false) {
             #if DEBUG
                 if (strIsCapitals && (str != str.ToUpper())) throw new Exception();