From 8b1866fff245c1296cab7113c584141db0b722d2 Mon Sep 17 00:00:00 2001
From: ASNiVOR <coding@asnitech.co.uk>
Date: Fri, 20 Jan 2017 12:15:42 +0000
Subject: [PATCH] Completed config tooltip implementation

---
 MedLaunch/Classes/ConfigToolTips.cs           |  370 +++
 MedLaunch/Classes/HtmlToXaml/CssStylesheet.cs |  252 ++
 MedLaunch/Classes/HtmlToXaml/HtmlCSSParser.cs |  841 +++++
 .../Classes/HtmlToXaml/HtmlLexicalAnalyzer.cs |  744 +++++
 MedLaunch/Classes/HtmlToXaml/HtmlParser.cs    |  483 +++
 MedLaunch/Classes/HtmlToXaml/HtmlSchema.cs    |  730 +++++
 .../Classes/HtmlToXaml/HtmlToXamlConverter.cs | 2753 +++++++++++++++++
 MedLaunch/Classes/HtmlToXaml/HtmlTokenType.cs |   25 +
 .../VisualHandlers/ConfigsVisualHandler.cs    |    8 +-
 MedLaunch/Data/System/ToolTips.json           | 2318 ++++++++++++++
 MedLaunch/MainWindow.xaml                     |  256 +-
 MedLaunch/MainWindow.xaml.cs                  |   27 +-
 MedLaunch/MedLaunch.csproj                    |   11 +
 MedLaunch/Models/GlobalSettings.cs            |   12 +-
 MedLaunch/Properties/AssemblyInfo.cs          |    4 +-
 15 files changed, 8592 insertions(+), 242 deletions(-)
 create mode 100644 MedLaunch/Classes/ConfigToolTips.cs
 create mode 100644 MedLaunch/Classes/HtmlToXaml/CssStylesheet.cs
 create mode 100644 MedLaunch/Classes/HtmlToXaml/HtmlCSSParser.cs
 create mode 100644 MedLaunch/Classes/HtmlToXaml/HtmlLexicalAnalyzer.cs
 create mode 100644 MedLaunch/Classes/HtmlToXaml/HtmlParser.cs
 create mode 100644 MedLaunch/Classes/HtmlToXaml/HtmlSchema.cs
 create mode 100644 MedLaunch/Classes/HtmlToXaml/HtmlToXamlConverter.cs
 create mode 100644 MedLaunch/Classes/HtmlToXaml/HtmlTokenType.cs
 create mode 100644 MedLaunch/Data/System/ToolTips.json

diff --git a/MedLaunch/Classes/ConfigToolTips.cs b/MedLaunch/Classes/ConfigToolTips.cs
new file mode 100644
index 0000000..667fb46
--- /dev/null
+++ b/MedLaunch/Classes/ConfigToolTips.cs
@@ -0,0 +1,370 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+using HtmlAgilityPack;
+using Newtonsoft.Json;
+using System.IO;
+using System.Windows.Controls;
+using System.Windows;
+using Xceed.Wpf.Toolkit;
+using MahApps.Metro.Controls;
+using MedLaunch.Classes.HtmlToXaml;
+
+namespace MedLaunch.Classes
+{
+    public class ConfigToolTips
+    {
+        /// <summary>
+        /// 1 = set tooltips
+        /// 2 = unset tooltips
+        /// </summary>
+        /// <param name="SetOrUnset"></param>
+        public static void SetToolTips(int SetOrUnset)
+        {
+            
+            // get all config controls
+            MainWindow mw = Application.Current.Windows.OfType<MainWindow>().FirstOrDefault();
+            // find the root grid
+            Grid RootGrid = (Grid)mw.FindName("RootGrid");
+            UIHandler ui = UIHandler.GetChildren(RootGrid);
+
+            UIHandler u = new UIHandler();
+            u.Buttons = ui.Buttons.Where(a => a.Name.StartsWith("cfg_") || a.Name.StartsWith("cfglbl_")).ToList() ?? new List<Button>();
+            u.CheckBoxes = ui.CheckBoxes.Where(a => a.Name.StartsWith("cfg_") || a.Name.StartsWith("cfglbl_")).ToList() ?? new List<CheckBox>();
+            u.Colorpickers = ui.Colorpickers.Where(a => a.Name.StartsWith("cfg_") || a.Name.StartsWith("cfglbl_")).ToList() ?? new List<ColorPicker>();
+            u.ComboBoxes = ui.ComboBoxes.Where(a => a.Name.StartsWith("cfg_") || a.Name.StartsWith("cfglbl_")).ToList() ?? new List<ComboBox>();
+            u.Labels = ui.Labels.Where(a => a.Name.StartsWith("cfg_") || a.Name.StartsWith("cfglbl_")).ToList() ?? new List<Label>();
+            u.NumericUpDowns = ui.NumericUpDowns.Where(a => a.Name.StartsWith("cfg_") || a.Name.StartsWith("cfglbl_")).ToList() ?? new List<NumericUpDown>();
+            u.RadioButtons = ui.RadioButtons.Where(a => a.Name.StartsWith("cfg_") || a.Name.StartsWith("cfglbl_")).ToList() ?? new List<RadioButton>();
+            u.Sliders = ui.Sliders.Where(a => a.Name.StartsWith("cfg_") || a.Name.StartsWith("cfglbl_")).ToList() ?? new List<Slider>();
+            u.TextBoxes = ui.TextBoxes.Where(a => a.Name.StartsWith("cfg_") || a.Name.StartsWith("cfglbl_")).ToList() ?? new List<TextBox>();
+            u.ToggleButtons = new List<System.Windows.Controls.Primitives.ToggleButton>();
+
+            // load json
+            List<ToolTips> tips = JsonConvert.DeserializeObject<List<ToolTips>>(File.ReadAllText(AppDomain.CurrentDomain.BaseDirectory + @"Data\System\ToolTips.json"));
+
+            // now iterate through each set of controls and assign the tooltips
+            foreach (Button c in u.Buttons)
+            {
+                string Name = c.Name.Replace("cfglbl_", "").Replace("cfg_", "").Replace("__", ".");
+                // lookup description
+                var bu = tips.Where(a => a.Command.Contains(Name)).ToList();
+                if (bu.Count() > 0)
+                {
+                    ToolTip tool = new ToolTip();
+                    TextBlock tb = new TextBlock();
+                    tb.TextWrapping = TextWrapping.Wrap;
+                    tb.MaxWidth = 800;
+                    tb.Text = bu.First().Description;
+                    tool.Content = tb;
+                    if (c.ToolTip == null)
+                    {
+                        c.ToolTip = tool;
+                    }
+                }
+            }
+
+            foreach (CheckBox c in u.CheckBoxes)
+            {
+                string Name = c.Name.Replace("cfglbl_", "").Replace("cfg_", "").Replace("__", ".");
+                // lookup description
+                var bu = tips.Where(a => a.Command.Contains(Name)).ToList();
+                if (bu.Count() > 0)
+                {
+                    ToolTip tool = new ToolTip();
+                    TextBlock tb = new TextBlock();
+                    tb.TextWrapping = TextWrapping.Wrap;
+                    tb.MaxWidth = 800;
+                    tb.Text = bu.First().Description;
+                    tool.Content = tb;
+                    if (c.ToolTip == null)
+                    {
+                        c.ToolTip = tool;
+                    }
+                }
+            }
+
+            foreach (ColorPicker c in u.Colorpickers)
+            {
+                string Name = c.Name.Replace("cfglbl_", "").Replace("cfg_", "").Replace("__", ".");
+                // lookup description
+                var bu = tips.Where(a => a.Command.Contains(Name)).ToList();
+                if (bu.Count() > 0)
+                {
+                    ToolTip tool = new ToolTip();
+                    TextBlock tb = new TextBlock();
+                    tb.TextWrapping = TextWrapping.Wrap;
+                    tb.MaxWidth = 800;
+                    tb.Text = bu.First().Description;
+                    tool.Content = tb;
+                    if (c.ToolTip == null)
+                    {
+                        c.ToolTip = tool;
+                    }
+                }
+            }
+
+            foreach (ComboBox c in u.ComboBoxes)
+            {
+                string Name = c.Name.Replace("cfglbl_", "").Replace("cfg_", "").Replace("__", ".");
+                // lookup description
+                var bu = tips.Where(a => a.Command.Contains(Name)).ToList();
+                if (bu.Count() > 0)
+                {
+                    ToolTip tool = new ToolTip();
+                    TextBlock tb = new TextBlock();
+                    tb.TextWrapping = TextWrapping.Wrap;
+                    tb.MaxWidth = 800;
+                    tb.Text = bu.First().Description;
+                    tool.Content = tb;
+                    if (c.ToolTip == null)
+                    {
+                        c.ToolTip = tool;
+                    }
+                }
+            }
+
+            foreach (Label c in u.Labels)
+            {
+                string Name = c.Name.Replace("cfglbl_", "").Replace("cfg_", "").Replace("__", ".");
+                // lookup description
+                var bu = tips.Where(a => a.Command.Contains(Name)).ToList();
+                if (bu.Count() > 0)
+                {
+                    ToolTip tool = new ToolTip();
+                    TextBlock tb = new TextBlock();
+                    tb.TextWrapping = TextWrapping.Wrap;
+                    tb.MaxWidth = 800;
+                    tb.Text = bu.First().Description;
+                    tool.Content = tb;
+                    if (c.ToolTip == null)
+                    {
+                        c.ToolTip = tool;
+                    }
+                }
+            }
+            
+            foreach (NumericUpDown c in u.NumericUpDowns)
+            {
+                string Name = c.Name.Replace("cfglbl_", "").Replace("cfg_", "").Replace("__", ".");
+                // lookup description
+                var bu = tips.Where(a => a.Command.Contains(Name)).ToList();
+                if (bu.Count() > 0)
+                {
+                    ToolTip tool = new ToolTip();
+                    TextBlock tb = new TextBlock();
+                    tb.TextWrapping = TextWrapping.Wrap;
+                    tb.MaxWidth = 800;
+                    tb.Text = bu.First().Description;
+                    tool.Content = tb;
+                    if (c.ToolTip == null)
+                    {
+                        c.ToolTip = tool;
+                    }
+                }
+            }
+            
+
+            foreach (RadioButton c in u.RadioButtons)
+            {
+                string Name = c.Name.Replace("cfglbl_", "").Replace("cfg_", "").Replace("__", ".");
+                // lookup description
+                var bu = tips.Where(a => a.Command.Contains(Name)).ToList();
+                if (bu.Count() > 0)
+                {
+                    ToolTip tool = new ToolTip();
+                    TextBlock tb = new TextBlock();
+                    tb.TextWrapping = TextWrapping.Wrap;
+                    tb.MaxWidth = 800;
+                    tb.Text = bu.First().Description;
+                    tool.Content = tb;
+                    if (c.ToolTip == null)
+                    {
+                        c.ToolTip = tool;
+                    }
+                }
+            }
+
+            foreach (Slider c in u.Sliders)
+            {
+                string Name = c.Name.Replace("cfglbl_", "").Replace("cfg_", "").Replace("__", ".");
+                // lookup description
+                var bu = tips.Where(a => a.Command.Contains(Name)).ToList();
+                if (bu.Count() > 0)
+                {
+                    ToolTip tool = new ToolTip();
+                    TextBlock tb = new TextBlock();
+                    tb.TextWrapping = TextWrapping.Wrap;
+                    tb.MaxWidth = 800;
+                    tb.Text = bu.First().Description;
+                    tool.Content = tb;
+                    if (c.ToolTip == null)
+                    {
+                        c.ToolTip = tool;
+                    }
+                }
+            }
+
+            // skip textboxes
+
+        }
+
+        public static List<ToolTips> GetDocumentationStrings()
+        {
+            string baseUrl = "https://mednafen.github.io/documentation/";
+            List<ToolTips> tt = new List<ToolTips>();
+
+            // get all webpages
+            string documentation = new WebClient().DownloadString(baseUrl);
+            string lynx = new WebClient().DownloadString(baseUrl + "lynx.html");
+            string gb = new WebClient().DownloadString(baseUrl + "gb.html");
+            string gba = new WebClient().DownloadString(baseUrl + "gba.html");
+            string ngp = new WebClient().DownloadString(baseUrl + "ngp.html");
+            string nes = new WebClient().DownloadString(baseUrl + "nes.html");
+            string pce_fast = new WebClient().DownloadString(baseUrl + "pce_fast.html");
+            string pce = new WebClient().DownloadString(baseUrl + "pce.html");
+            string gg = new WebClient().DownloadString(baseUrl + "gg.html");
+            string md = new WebClient().DownloadString(baseUrl + "md.html");
+            string sms = new WebClient().DownloadString(baseUrl + "sms.html");
+            string ss = new WebClient().DownloadString(baseUrl + "ss.html");
+            string psx = new WebClient().DownloadString(baseUrl + "psx.html");
+            string snes_faust = new WebClient().DownloadString(baseUrl + "snes_faust.html");
+            string snes = new WebClient().DownloadString(baseUrl + "snes.html");
+            string vb = new WebClient().DownloadString(baseUrl + "vb.html");
+            string wswan = new WebClient().DownloadString(baseUrl + "wswan.html");
+
+
+            // parse individual system documentation
+            ParseSystems(tt, lynx);
+            ParseSystems(tt, gb);
+            ParseSystems(tt, gba);
+            ParseSystems(tt, ngp);
+            ParseSystems(tt, nes);
+            ParseSystems(tt, pce_fast);
+            ParseSystems(tt, pce);
+            ParseSystems(tt, gg);
+            ParseSystems(tt, md);
+            ParseSystems(tt, sms);
+            ParseSystems(tt, ss);
+            ParseSystems(tt, psx);
+            ParseSystems(tt, snes_faust);
+            ParseSystems(tt, snes);
+            ParseSystems(tt, vb);
+            ParseSystems(tt, wswan);
+
+            // parse main documentation
+            ParseMain(tt, documentation);
+
+            // now tt contains all documentation config commands - output to json
+            string saveLocation = AppDomain.CurrentDomain.BaseDirectory + @"..\..\Data\System\ToolTips.json";
+            string json = JsonConvert.SerializeObject(tt, Formatting.Indented);
+            File.WriteAllText(saveLocation, json);
+
+            return tt;
+
+        }
+
+        public static void ParseMain(List<ToolTips> ttList, string str)
+        {
+            HtmlDocument doc = new HtmlDocument();
+            doc.LoadHtml(str);
+            var tds = doc.DocumentNode.SelectNodes("//td[@class='ColE']");
+            foreach (HtmlNode node in tds)
+            {
+                string html = node.InnerHtml;
+                string[] arr = html.Split('>');
+                string command = arr[0].Replace("<a name=\"", "").Replace("\"", "");
+
+                StringBuilder sb = new StringBuilder();
+                for (int i = 1; i < arr.Length; i++)
+                {
+                    sb.Append(arr[i]);
+                    sb.Append(">");
+                }
+
+                string h = sb.ToString();
+                string desc = h.Replace("</a>", "")
+                    .Replace("<p>", "\n\n")
+                    //.Replace("</p>", "\n\n")
+                    .Replace("<br>", "\n")
+                    .Replace("<ul>", "\n")
+                    .Replace("<li>", "\n")
+                    .Replace("</li>", "")
+                    .Replace("</ul>", "")
+                    .Replace("</ul", "")
+                    .Replace("</p", "")
+                    .Replace("<b>", "")
+                    .Replace("</b>", "")
+                    .TrimEnd('>');
+
+
+                //string desc = node.InnerText.Replace("<p>", "&#x0a;");
+
+                ToolTips t = new ToolTips();
+                t.Command = command;
+                t.Description = desc;
+
+                ttList.Add(t);
+            }
+        }
+
+        public static void ParseSystems(List<ToolTips> ttList, string str)
+        {
+            HtmlDocument doc = new HtmlDocument();
+            doc.LoadHtml(str);
+            var tds = doc.DocumentNode.SelectNodes("//td[@class='ColE']");
+            foreach (HtmlNode node in tds)
+            {
+                string html = node.InnerHtml;
+                string[] arr = html.Split('>');
+                string command = arr[0].Replace("<a name=\"", "").Replace("\"", "");
+
+                StringBuilder sb = new StringBuilder();
+                for (int i = 1; i < arr.Length; i++)
+                {
+                    sb.Append(arr[i]);
+                    sb.Append(">");
+                }
+
+                string h = sb.ToString();
+                string desc = h.Replace("</a>", "")
+                    .Replace("<p>", "\n\n")
+                    //.Replace("</p>", "\n\n")
+                    .Replace("<br>", "\n")
+                    .Replace("<ul>", "\n")
+                    .Replace("<li>", "\n")
+                    .Replace("</li>", "")
+                    .Replace("</ul>", "")
+                    .Replace("</ul", "")
+                    .Replace("</p", "")
+                    .Replace("<b>", "")
+                    .Replace("</b>", "")
+                    .TrimEnd('>');
+
+                string test = HtmlToXamlConverter.ConvertHtmlToXaml(h, false);
+
+
+                //string desc = node.InnerText.Replace("<p>", "&#x0a;");
+
+                ToolTips t = new ToolTips();
+                
+                t.Command = command;
+                t.Description = desc;
+
+                ttList.Add(t);
+            }
+           
+        }
+
+
+    }
+
+    public class ToolTips
+    {
+        public string Command { get; set; }
+        public string Description { get; set; }
+    }
+}
diff --git a/MedLaunch/Classes/HtmlToXaml/CssStylesheet.cs b/MedLaunch/Classes/HtmlToXaml/CssStylesheet.cs
new file mode 100644
index 0000000..5ba3641
--- /dev/null
+++ b/MedLaunch/Classes/HtmlToXaml/CssStylesheet.cs
@@ -0,0 +1,252 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using System.Xml;
+
+namespace MedLaunch.Classes.HtmlToXaml
+{
+    internal class CssStylesheet
+    {
+        private List<StyleDefinition> _styleDefinitions;
+        // Constructor
+        public CssStylesheet(XmlElement htmlElement)
+        {
+            if (htmlElement != null)
+            {
+                DiscoverStyleDefinitions(htmlElement);
+            }
+        }
+
+        // Recursively traverses an html tree, discovers STYLE elements and creates a style definition table
+        // for further cascading style application
+        public void DiscoverStyleDefinitions(XmlElement htmlElement)
+        {
+            if (htmlElement.LocalName.ToLower() == "link")
+            {
+                return;
+                //  Add LINK elements processing for included stylesheets
+                // <LINK href="http://sc.msn.com/global/css/ptnr/orange.css" type=text/css \r\nrel=stylesheet>
+            }
+
+            if (htmlElement.LocalName.ToLower() != "style")
+            {
+                // This is not a STYLE element. Recurse into it
+                for (var htmlChildNode = htmlElement.FirstChild;
+                    htmlChildNode != null;
+                    htmlChildNode = htmlChildNode.NextSibling)
+                {
+                    if (htmlChildNode is XmlElement)
+                    {
+                        DiscoverStyleDefinitions((XmlElement)htmlChildNode);
+                    }
+                }
+                return;
+            }
+
+            // Add style definitions from this style.
+
+            // Collect all text from this style definition
+            var stylesheetBuffer = new StringBuilder();
+
+            for (var htmlChildNode = htmlElement.FirstChild;
+                htmlChildNode != null;
+                htmlChildNode = htmlChildNode.NextSibling)
+            {
+                if (htmlChildNode is XmlText || htmlChildNode is XmlComment)
+                {
+                    stylesheetBuffer.Append(RemoveComments(htmlChildNode.Value));
+                }
+            }
+
+            // CssStylesheet has the following syntactical structure:
+            //     @import declaration;
+            //     selector { definition }
+            // where "selector" is one of: ".classname", "tagname"
+            // It can contain comments in the following form: /*...*/
+
+            var nextCharacterIndex = 0;
+            while (nextCharacterIndex < stylesheetBuffer.Length)
+            {
+                // Extract selector
+                var selectorStart = nextCharacterIndex;
+                while (nextCharacterIndex < stylesheetBuffer.Length && stylesheetBuffer[nextCharacterIndex] != '{')
+                {
+                    // Skip declaration directive starting from @
+                    if (stylesheetBuffer[nextCharacterIndex] == '@')
+                    {
+                        while (nextCharacterIndex < stylesheetBuffer.Length &&
+                               stylesheetBuffer[nextCharacterIndex] != ';')
+                        {
+                            nextCharacterIndex++;
+                        }
+                        selectorStart = nextCharacterIndex + 1;
+                    }
+                    nextCharacterIndex++;
+                }
+
+                if (nextCharacterIndex < stylesheetBuffer.Length)
+                {
+                    // Extract definition
+                    var definitionStart = nextCharacterIndex;
+                    while (nextCharacterIndex < stylesheetBuffer.Length && stylesheetBuffer[nextCharacterIndex] != '}')
+                    {
+                        nextCharacterIndex++;
+                    }
+
+                    // Define a style
+                    if (nextCharacterIndex - definitionStart > 2)
+                    {
+                        AddStyleDefinition(
+                            stylesheetBuffer.ToString(selectorStart, definitionStart - selectorStart),
+                            stylesheetBuffer.ToString(definitionStart + 1, nextCharacterIndex - definitionStart - 2));
+                    }
+
+                    // Skip closing brace
+                    if (nextCharacterIndex < stylesheetBuffer.Length)
+                    {
+                        Debug.Assert(stylesheetBuffer[nextCharacterIndex] == '}');
+                        nextCharacterIndex++;
+                    }
+                }
+            }
+        }
+
+        // Returns a string with all c-style comments replaced by spaces
+        private string RemoveComments(string text)
+        {
+            var commentStart = text.IndexOf("/*", StringComparison.Ordinal);
+            if (commentStart < 0)
+            {
+                return text;
+            }
+
+            var commentEnd = text.IndexOf("*/", commentStart + 2, StringComparison.Ordinal);
+            if (commentEnd < 0)
+            {
+                return text.Substring(0, commentStart);
+            }
+
+            return text.Substring(0, commentStart) + " " + RemoveComments(text.Substring(commentEnd + 2));
+        }
+
+        public void AddStyleDefinition(string selector, string definition)
+        {
+            // Notrmalize parameter values
+            selector = selector.Trim().ToLower();
+            definition = definition.Trim().ToLower();
+            if (selector.Length == 0 || definition.Length == 0)
+            {
+                return;
+            }
+
+            if (_styleDefinitions == null)
+            {
+                _styleDefinitions = new List<StyleDefinition>();
+            }
+
+            var simpleSelectors = selector.Split(',');
+
+            foreach (string t in simpleSelectors)
+            {
+                var simpleSelector = t.Trim();
+                if (simpleSelector.Length > 0)
+                {
+                    _styleDefinitions.Add(new StyleDefinition(simpleSelector, definition));
+                }
+            }
+        }
+
+        public string GetStyle(string elementName, List<XmlElement> sourceContext)
+        {
+            Debug.Assert(sourceContext.Count > 0);
+            Debug.Assert(elementName == sourceContext[sourceContext.Count - 1].LocalName);
+
+            //  Add id processing for style selectors
+            if (_styleDefinitions != null)
+            {
+                for (var i = _styleDefinitions.Count - 1; i >= 0; i--)
+                {
+                    var selector = _styleDefinitions[i].Selector;
+
+                    var selectorLevels = selector.Split(' ');
+
+                    var indexInSelector = selectorLevels.Length - 1;
+                    var indexInContext = sourceContext.Count - 1;
+                    var selectorLevel = selectorLevels[indexInSelector].Trim();
+
+                    if (MatchSelectorLevel(selectorLevel, sourceContext[sourceContext.Count - 1]))
+                    {
+                        return _styleDefinitions[i].Definition;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        private bool MatchSelectorLevel(string selectorLevel, XmlElement xmlElement)
+        {
+            if (selectorLevel.Length == 0)
+            {
+                return false;
+            }
+
+            var indexOfDot = selectorLevel.IndexOf('.');
+            var indexOfPound = selectorLevel.IndexOf('#');
+
+            string selectorClass = null;
+            string selectorId = null;
+            string selectorTag = null;
+            if (indexOfDot >= 0)
+            {
+                if (indexOfDot > 0)
+                {
+                    selectorTag = selectorLevel.Substring(0, indexOfDot);
+                }
+                selectorClass = selectorLevel.Substring(indexOfDot + 1);
+            }
+            else if (indexOfPound >= 0)
+            {
+                if (indexOfPound > 0)
+                {
+                    selectorTag = selectorLevel.Substring(0, indexOfPound);
+                }
+                selectorId = selectorLevel.Substring(indexOfPound + 1);
+            }
+            else
+            {
+                selectorTag = selectorLevel;
+            }
+
+            if (selectorTag != null && selectorTag != xmlElement.LocalName)
+            {
+                return false;
+            }
+
+            if (selectorId != null && HtmlToXamlConverter.GetAttribute(xmlElement, "id") != selectorId)
+            {
+                return false;
+            }
+
+            if (selectorClass != null && HtmlToXamlConverter.GetAttribute(xmlElement, "class") != selectorClass)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        private class StyleDefinition
+        {
+            public readonly string Definition;
+            public readonly string Selector;
+
+            public StyleDefinition(string selector, string definition)
+            {
+                Selector = selector;
+                Definition = definition;
+            }
+        }
+    }
+}
diff --git a/MedLaunch/Classes/HtmlToXaml/HtmlCSSParser.cs b/MedLaunch/Classes/HtmlToXaml/HtmlCSSParser.cs
new file mode 100644
index 0000000..e50e991
--- /dev/null
+++ b/MedLaunch/Classes/HtmlToXaml/HtmlCSSParser.cs
@@ -0,0 +1,841 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Xml;
+
+namespace MedLaunch.Classes.HtmlToXaml
+{
+    // DependencyProperty
+
+    // TextElement
+
+    internal static class HtmlCssParser
+    {
+        private static readonly string[] Colors =
+        {
+            "aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige", "bisque", "black", "blanchedalmond",
+            "blue", "blueviolet", "brown", "burlywood", "cadetblue", "chartreuse", "chocolate", "coral",
+            "cornflowerblue", "cornsilk", "crimson", "cyan", "darkblue", "darkcyan", "darkgoldenrod", "darkgray",
+            "darkgreen", "darkkhaki", "darkmagenta", "darkolivegreen", "darkorange", "darkorchid", "darkred",
+            "darksalmon", "darkseagreen", "darkslateblue", "darkslategray", "darkturquoise", "darkviolet", "deeppink",
+            "deepskyblue", "dimgray", "dodgerblue", "firebrick", "floralwhite", "forestgreen", "fuchsia", "gainsboro",
+            "ghostwhite", "gold", "goldenrod", "gray", "green", "greenyellow", "honeydew", "hotpink", "indianred",
+            "indigo", "ivory", "khaki", "lavender", "lavenderblush", "lawngreen", "lemonchiffon", "lightblue",
+            "lightcoral",
+            "lightcyan", "lightgoldenrodyellow", "lightgreen", "lightgrey", "lightpink", "lightsalmon", "lightseagreen",
+            "lightskyblue", "lightslategray", "lightsteelblue", "lightyellow", "lime", "limegreen", "linen", "magenta",
+            "maroon", "mediumaquamarine", "mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen",
+            "mediumslateblue",
+            "mediumspringgreen", "mediumturquoise", "mediumvioletred", "midnightblue", "mintcream", "mistyrose",
+            "moccasin",
+            "navajowhite", "navy", "oldlace", "olive", "olivedrab", "orange", "orangered", "orchid", "palegoldenrod",
+            "palegreen", "paleturquoise", "palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum",
+            "powderblue",
+            "purple", "red", "rosybrown", "royalblue", "saddlebrown", "salmon", "sandybrown", "seagreen", "seashell",
+            "sienna", "silver", "skyblue", "slateblue", "slategray", "snow", "springgreen", "steelblue", "tan", "teal",
+            "thistle", "tomato", "turquoise", "violet", "wheat", "white", "whitesmoke", "yellow", "yellowgreen"
+        };
+
+        private static readonly string[] SystemColors =
+        {
+            "activeborder", "activecaption", "appworkspace", "background", "buttonface", "buttonhighlight",
+            "buttonshadow",
+            "buttontext", "captiontext", "graytext", "highlight", "highlighttext", "inactiveborder", "inactivecaption",
+            "inactivecaptiontext", "infobackground", "infotext", "menu", "menutext", "scrollbar", "threeddarkshadow",
+            "threedface", "threedhighlight", "threedlightshadow", "threedshadow", "window", "windowframe", "windowtext"
+        };
+
+        // .................................................................
+        //
+        // Pasring CSS font Property
+        //
+        // .................................................................
+
+        // CSS has five font properties: font-family, font-style, font-variant, font-weight, font-size.
+        // An aggregated "font" property lets you specify in one action all the five in combination
+        // with additional line-height property.
+        // 
+        // font-family: [<family-name>,]* [<family-name> | <generic-family>]
+        //    generic-family: serif | sans-serif | monospace | cursive | fantasy
+        //       The list of families sets priorities to choose fonts;
+        //       Quotes not allowed around generic-family names
+        // font-style: normal | italic | oblique
+        // font-variant: normal | small-caps
+        // font-weight: normal | bold | bolder | lighter | 100 ... 900 |
+        //    Default is "normal", normal==400
+        // font-size: <absolute-size> | <relative-size> | <length> | <percentage>
+        //    absolute-size: xx-small | x-small | small | medium | large | x-large | xx-large
+        //    relative-size: larger | smaller
+        //    length: <point> | <pica> | <ex> | <em> | <points> | <millimeters> | <centimeters> | <inches>
+        //    Default: medium
+        // font: [ <font-style> || <font-variant> || <font-weight ]? <font-size> [ / <line-height> ]? <font-family>
+
+        private static readonly string[] FontGenericFamilies =
+        {
+            "serif", "sans-serif", "monospace", "cursive", "fantasy"
+        };
+
+        private static readonly string[] FontStyles = { "normal", "italic", "oblique" };
+        private static readonly string[] FontVariants = { "normal", "small-caps" };
+
+        private static readonly string[] FontWeights =
+        {
+            "normal", "bold", "bolder", "lighter", "100", "200", "300",
+            "400", "500", "600", "700", "800", "900"
+        };
+
+        private static readonly string[] FontAbsoluteSizes =
+        {
+            "xx-small", "x-small", "small", "medium", "large",
+            "x-large", "xx-large"
+        };
+
+        private static readonly string[] FontRelativeSizes = { "larger", "smaller" };
+
+        private static readonly string[] FontSizeUnits = { "px", "mm", "cm", "in", "pt", "pc", "em", "ex", "%" };
+
+        // .................................................................
+        //
+        // Pasring CSS list-style Property
+        //
+        // .................................................................
+
+        // list-style: [ <list-style-type> || <list-style-position> || <list-style-image> ]
+
+        private static readonly string[] ListStyleTypes =
+        {
+            "disc", "circle", "square", "decimal", "lower-roman",
+            "upper-roman", "lower-alpha", "upper-alpha", "none"
+        };
+
+        private static readonly string[] ListStylePositions = { "inside", "outside" };
+        // .................................................................
+        //
+        // Pasring CSS text-decorations Property
+        //
+        // .................................................................
+
+        private static readonly string[] TextDecorations = { "none", "underline", "overline", "line-through", "blink" };
+
+        // .................................................................
+        //
+        // Pasring CSS text-transform Property
+        //
+        // .................................................................
+
+        private static readonly string[] TextTransforms = { "none", "capitalize", "uppercase", "lowercase" };
+        // .................................................................
+        //
+        // Pasring CSS text-align Property
+        //
+        // .................................................................
+
+        private static readonly string[] TextAligns = { "left", "right", "center", "justify" };
+        // .................................................................
+        //
+        // Pasring CSS vertical-align Property
+        //
+        // .................................................................
+
+        private static readonly string[] VerticalAligns =
+        {
+            "baseline", "sub", "super", "top", "text-top", "middle",
+            "bottom", "text-bottom"
+        };
+
+        // .................................................................
+        //
+        // Pasring CSS float Property
+        //
+        // .................................................................
+
+        private static readonly string[] Floats = { "left", "right", "none" };
+        // .................................................................
+        //
+        // Pasring CSS clear Property
+        //
+        // .................................................................
+
+        private static readonly string[] Clears = { "none", "left", "right", "both" };
+        // .................................................................
+        //
+        // Pasring CSS border-style Propertie
+        //
+        // .................................................................
+
+        private static readonly string[] BorderStyles =
+        {
+            "none", "dotted", "dashed", "solid", "double", "groove",
+            "ridge", "inset", "outset"
+        };
+
+        // .................................................................
+        //
+        //  What are these definitions doing here:
+        //
+        // .................................................................
+
+        private static string[] _blocks = { "block", "inline", "list-item", "none" };
+        // .................................................................
+        //
+        // Processing CSS Attributes
+        //
+        // .................................................................
+
+        internal static void GetElementPropertiesFromCssAttributes(XmlElement htmlElement, string elementName,
+            CssStylesheet stylesheet, Hashtable localProperties, List<XmlElement> sourceContext)
+        {
+            var styleFromStylesheet = stylesheet.GetStyle(elementName, sourceContext);
+
+            var styleInline = HtmlToXamlConverter.GetAttribute(htmlElement, "style");
+
+            // Combine styles from stylesheet and from inline attribute.
+            // The order is important - the latter styles will override the former.
+            var style = styleFromStylesheet ?? null;
+            if (styleInline != null)
+            {
+                style = style == null ? styleInline : (style + ";" + styleInline);
+            }
+
+            // Apply local style to current formatting properties
+            if (style != null)
+            {
+                var styleValues = style.Split(';');
+                foreach (string t in styleValues)
+                {
+                    string[] styleNameValue;
+
+                    styleNameValue = t.Split(':');
+                    if (styleNameValue.Length == 2)
+                    {
+                        var styleName = styleNameValue[0].Trim().ToLower();
+                        var styleValue = HtmlToXamlConverter.UnQuote(styleNameValue[1].Trim()).ToLower();
+                        var nextIndex = 0;
+
+                        switch (styleName)
+                        {
+                            case "font":
+                                ParseCssFont(styleValue, localProperties);
+                                break;
+                            case "font-family":
+                                ParseCssFontFamily(styleValue, ref nextIndex, localProperties);
+                                break;
+                            case "font-size":
+                                ParseCssSize(styleValue, ref nextIndex, localProperties, "font-size",
+                                    /*mustBeNonNegative:*/true);
+                                break;
+                            case "font-style":
+                                ParseCssFontStyle(styleValue, ref nextIndex, localProperties);
+                                break;
+                            case "font-weight":
+                                ParseCssFontWeight(styleValue, ref nextIndex, localProperties);
+                                break;
+                            case "font-variant":
+                                ParseCssFontVariant(styleValue, ref nextIndex, localProperties);
+                                break;
+                            case "line-height":
+                                ParseCssSize(styleValue, ref nextIndex, localProperties, "line-height",
+                                    /*mustBeNonNegative:*/true);
+                                break;
+                            case "word-spacing":
+                                //  Implement word-spacing conversion
+                                break;
+                            case "letter-spacing":
+                                //  Implement letter-spacing conversion
+                                break;
+                            case "color":
+                                ParseCssColor(styleValue, ref nextIndex, localProperties, "color");
+                                break;
+
+                            case "text-decoration":
+                                ParseCssTextDecoration(styleValue, ref nextIndex, localProperties);
+                                break;
+
+                            case "text-transform":
+                                ParseCssTextTransform(styleValue, ref nextIndex, localProperties);
+                                break;
+
+                            case "background-color":
+                                ParseCssColor(styleValue, ref nextIndex, localProperties, "background-color");
+                                break;
+                            case "background":
+                                // TODO: need to parse composite background property
+                                ParseCssBackground(styleValue, ref nextIndex, localProperties);
+                                break;
+
+                            case "text-align":
+                                ParseCssTextAlign(styleValue, ref nextIndex, localProperties);
+                                break;
+                            case "vertical-align":
+                                ParseCssVerticalAlign(styleValue, ref nextIndex, localProperties);
+                                break;
+                            case "text-indent":
+                                ParseCssSize(styleValue, ref nextIndex, localProperties, "text-indent",
+                                    /*mustBeNonNegative:*/false);
+                                break;
+
+                            case "width":
+                            case "height":
+                                ParseCssSize(styleValue, ref nextIndex, localProperties, styleName,
+                                    /*mustBeNonNegative:*/true);
+                                break;
+
+                            case "margin": // top/right/bottom/left
+                                ParseCssRectangleProperty(styleValue, ref nextIndex, localProperties, styleName);
+                                break;
+                            case "margin-top":
+                            case "margin-right":
+                            case "margin-bottom":
+                            case "margin-left":
+                                ParseCssSize(styleValue, ref nextIndex, localProperties, styleName,
+                                    /*mustBeNonNegative:*/true);
+                                break;
+
+                            case "padding":
+                                ParseCssRectangleProperty(styleValue, ref nextIndex, localProperties, styleName);
+                                break;
+                            case "padding-top":
+                            case "padding-right":
+                            case "padding-bottom":
+                            case "padding-left":
+                                ParseCssSize(styleValue, ref nextIndex, localProperties, styleName,
+                                    /*mustBeNonNegative:*/true);
+                                break;
+
+                            case "border":
+                                ParseCssBorder(styleValue, ref nextIndex, localProperties);
+                                break;
+                            case "border-style":
+                            case "border-width":
+                            case "border-color":
+                                ParseCssRectangleProperty(styleValue, ref nextIndex, localProperties, styleName);
+                                break;
+                            case "border-top":
+                            case "border-right":
+                            case "border-left":
+                            case "border-bottom":
+                                //  Parse css border style
+                                break;
+
+                            // NOTE: css names for elementary border styles have side indications in the middle (top/bottom/left/right)
+                            // In our internal notation we intentionally put them at the end - to unify processing in ParseCssRectangleProperty method
+                            case "border-top-style":
+                            case "border-right-style":
+                            case "border-left-style":
+                            case "border-bottom-style":
+                            case "border-top-color":
+                            case "border-right-color":
+                            case "border-left-color":
+                            case "border-bottom-color":
+                            case "border-top-width":
+                            case "border-right-width":
+                            case "border-left-width":
+                            case "border-bottom-width":
+                                //  Parse css border style
+                                break;
+
+                            case "display":
+                                //  Implement display style conversion
+                                break;
+
+                            case "float":
+                                ParseCssFloat(styleValue, ref nextIndex, localProperties);
+                                break;
+                            case "clear":
+                                ParseCssClear(styleValue, ref nextIndex, localProperties);
+                                break;
+
+                            default:
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+
+        // .................................................................
+        //
+        // Parsing CSS - Lexical Helpers
+        //
+        // .................................................................
+
+        // Skips whitespaces in style values
+        private static void ParseWhiteSpace(string styleValue, ref int nextIndex)
+        {
+            while (nextIndex < styleValue.Length && char.IsWhiteSpace(styleValue[nextIndex]))
+            {
+                nextIndex++;
+            }
+        }
+
+        // Checks if the following character matches to a given word and advances nextIndex
+        // by the word's length in case of success.
+        // Otherwise leaves nextIndex in place (except for possible whitespaces).
+        // Returns true or false depending on success or failure of matching.
+        private static bool ParseWord(string word, string styleValue, ref int nextIndex)
+        {
+            ParseWhiteSpace(styleValue, ref nextIndex);
+
+            for (var i = 0; i < word.Length; i++)
+            {
+                if (!(nextIndex + i < styleValue.Length && word[i] == styleValue[nextIndex + i]))
+                {
+                    return false;
+                }
+            }
+
+            if (nextIndex + word.Length < styleValue.Length && char.IsLetterOrDigit(styleValue[nextIndex + word.Length]))
+            {
+                return false;
+            }
+
+            nextIndex += word.Length;
+            return true;
+        }
+
+        // CHecks whether the following character sequence matches to one of the given words,
+        // and advances the nextIndex to matched word length.
+        // Returns null in case if there is no match or the word matched.
+        private static string ParseWordEnumeration(string[] words, string styleValue, ref int nextIndex)
+        {
+            foreach (string t in words)
+            {
+                if (ParseWord(t, styleValue, ref nextIndex))
+                {
+                    return t;
+                }
+            }
+
+            return null;
+        }
+
+        private static void ParseWordEnumeration(string[] words, string styleValue, ref int nextIndex,
+            Hashtable localProperties, string attributeName)
+        {
+            var attributeValue = ParseWordEnumeration(words, styleValue, ref nextIndex);
+            if (attributeValue != null)
+            {
+                localProperties[attributeName] = attributeValue;
+            }
+        }
+
+        private static string ParseCssSize(string styleValue, ref int nextIndex, bool mustBeNonNegative)
+        {
+            ParseWhiteSpace(styleValue, ref nextIndex);
+
+            var startIndex = nextIndex;
+
+            // Parse optional munis sign
+            if (nextIndex < styleValue.Length && styleValue[nextIndex] == '-')
+            {
+                nextIndex++;
+            }
+
+            if (nextIndex < styleValue.Length && char.IsDigit(styleValue[nextIndex]))
+            {
+                while (nextIndex < styleValue.Length &&
+                       (char.IsDigit(styleValue[nextIndex]) || styleValue[nextIndex] == '.'))
+                {
+                    nextIndex++;
+                }
+
+                var number = styleValue.Substring(startIndex, nextIndex - startIndex);
+
+                var unit = ParseWordEnumeration(FontSizeUnits, styleValue, ref nextIndex) ?? "px";
+
+                if (mustBeNonNegative && styleValue[startIndex] == '-')
+                {
+                    return "0";
+                }
+                return number + unit;
+            }
+
+            return null;
+        }
+
+        private static void ParseCssSize(string styleValue, ref int nextIndex, Hashtable localValues,
+            string propertyName,
+            bool mustBeNonNegative)
+        {
+            var length = ParseCssSize(styleValue, ref nextIndex, mustBeNonNegative);
+            if (length != null)
+            {
+                localValues[propertyName] = length;
+            }
+        }
+
+        private static string ParseCssColor(string styleValue, ref int nextIndex)
+        {
+            //  Implement color parsing
+            // rgb(100%,53.5%,10%)
+            // rgb(255,91,26)
+            // #FF5B1A
+            // black | silver | gray | ... | aqua
+            // transparent - for background-color
+            ParseWhiteSpace(styleValue, ref nextIndex);
+
+            string color = null;
+
+            if (nextIndex < styleValue.Length)
+            {
+                var startIndex = nextIndex;
+                var character = styleValue[nextIndex];
+
+                if (character == '#')
+                {
+                    nextIndex++;
+                    while (nextIndex < styleValue.Length)
+                    {
+                        character = char.ToUpper(styleValue[nextIndex]);
+                        if (!('0' <= character && character <= '9' || 'A' <= character && character <= 'F'))
+                        {
+                            break;
+                        }
+                        nextIndex++;
+                    }
+                    if (nextIndex > startIndex + 1)
+                    {
+                        color = styleValue.Substring(startIndex, nextIndex - startIndex);
+                    }
+                }
+                else if (styleValue.Substring(nextIndex, 3).ToLower() == "rbg")
+                {
+                    //  Implement real rgb() color parsing
+                    while (nextIndex < styleValue.Length && styleValue[nextIndex] != ')')
+                    {
+                        nextIndex++;
+                    }
+                    if (nextIndex < styleValue.Length)
+                    {
+                        nextIndex++; // to skip ')'
+                    }
+                    color = "gray"; // return bogus color
+                }
+                else if (char.IsLetter(character))
+                {
+                    color = ParseWordEnumeration(Colors, styleValue, ref nextIndex);
+                    if (color == null)
+                    {
+                        color = ParseWordEnumeration(SystemColors, styleValue, ref nextIndex);
+                        if (color != null)
+                        {
+                            //  Implement smarter system color converions into real colors
+                            color = "black";
+                        }
+                    }
+                }
+            }
+
+            return color;
+        }
+
+        private static void ParseCssColor(string styleValue, ref int nextIndex, Hashtable localValues,
+            string propertyName)
+        {
+            var color = ParseCssColor(styleValue, ref nextIndex);
+            if (color != null)
+            {
+                localValues[propertyName] = color;
+            }
+        }
+
+        // Parses CSS string fontStyle representing a value for css font attribute
+        private static void ParseCssFont(string styleValue, Hashtable localProperties)
+        {
+            var nextIndex = 0;
+
+            ParseCssFontStyle(styleValue, ref nextIndex, localProperties);
+            ParseCssFontVariant(styleValue, ref nextIndex, localProperties);
+            ParseCssFontWeight(styleValue, ref nextIndex, localProperties);
+
+            ParseCssSize(styleValue, ref nextIndex, localProperties, "font-size", /*mustBeNonNegative:*/true);
+
+            ParseWhiteSpace(styleValue, ref nextIndex);
+            if (nextIndex < styleValue.Length && styleValue[nextIndex] == '/')
+            {
+                nextIndex++;
+                ParseCssSize(styleValue, ref nextIndex, localProperties, "line-height", /*mustBeNonNegative:*/true);
+            }
+
+            ParseCssFontFamily(styleValue, ref nextIndex, localProperties);
+        }
+
+        private static void ParseCssFontStyle(string styleValue, ref int nextIndex, Hashtable localProperties)
+        {
+            ParseWordEnumeration(FontStyles, styleValue, ref nextIndex, localProperties, "font-style");
+        }
+
+        private static void ParseCssFontVariant(string styleValue, ref int nextIndex, Hashtable localProperties)
+        {
+            ParseWordEnumeration(FontVariants, styleValue, ref nextIndex, localProperties, "font-variant");
+        }
+
+        private static void ParseCssFontWeight(string styleValue, ref int nextIndex, Hashtable localProperties)
+        {
+            ParseWordEnumeration(FontWeights, styleValue, ref nextIndex, localProperties, "font-weight");
+        }
+
+        private static void ParseCssFontFamily(string styleValue, ref int nextIndex, Hashtable localProperties)
+        {
+            string fontFamilyList = null;
+
+            while (nextIndex < styleValue.Length)
+            {
+                // Try generic-family
+                var fontFamily = ParseWordEnumeration(FontGenericFamilies, styleValue, ref nextIndex);
+
+                if (fontFamily == null)
+                {
+                    // Try quoted font family name
+                    if (nextIndex < styleValue.Length && (styleValue[nextIndex] == '"' || styleValue[nextIndex] == '\''))
+                    {
+                        var quote = styleValue[nextIndex];
+
+                        nextIndex++;
+
+                        var startIndex = nextIndex;
+
+                        while (nextIndex < styleValue.Length && styleValue[nextIndex] != quote)
+                        {
+                            nextIndex++;
+                        }
+
+                        fontFamily = '"' + styleValue.Substring(startIndex, nextIndex - startIndex) + '"';
+                    }
+
+                    if (fontFamily == null)
+                    {
+                        // Try unquoted font family name
+                        var startIndex = nextIndex;
+                        while (nextIndex < styleValue.Length && styleValue[nextIndex] != ',' &&
+                               styleValue[nextIndex] != ';')
+                        {
+                            nextIndex++;
+                        }
+
+                        if (nextIndex > startIndex)
+                        {
+                            fontFamily = styleValue.Substring(startIndex, nextIndex - startIndex).Trim();
+                            if (fontFamily.Length == 0)
+                            {
+                                fontFamily = null;
+                            }
+                        }
+                    }
+                }
+
+                ParseWhiteSpace(styleValue, ref nextIndex);
+                if (nextIndex < styleValue.Length && styleValue[nextIndex] == ',')
+                {
+                    nextIndex++;
+                }
+
+                if (fontFamily != null)
+                {
+                    //  css font-family can contein a list of names. We only consider the first name from the list. Need a decision what to do with remaining names
+                    // fontFamilyList = (fontFamilyList == null) ? fontFamily : fontFamilyList + "," + fontFamily;
+                    if (fontFamilyList == null && fontFamily.Length > 0)
+                    {
+                        if (fontFamily[0] == '"' || fontFamily[0] == '\'')
+                        {
+                            // Unquote the font family name
+                            fontFamily = fontFamily.Substring(1, fontFamily.Length - 2);
+                        }
+                        fontFamilyList = fontFamily;
+                    }
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            if (fontFamilyList != null)
+            {
+                localProperties["font-family"] = fontFamilyList;
+            }
+        }
+
+        private static void ParseCssListStyle(string styleValue, Hashtable localProperties)
+        {
+            var nextIndex = 0;
+
+            while (nextIndex < styleValue.Length)
+            {
+                var listStyleType = ParseCssListStyleType(styleValue, ref nextIndex);
+                if (listStyleType != null)
+                {
+                    localProperties["list-style-type"] = listStyleType;
+                }
+                else
+                {
+                    var listStylePosition = ParseCssListStylePosition(styleValue, ref nextIndex);
+                    if (listStylePosition != null)
+                    {
+                        localProperties["list-style-position"] = listStylePosition;
+                    }
+                    else
+                    {
+                        var listStyleImage = ParseCssListStyleImage(styleValue, ref nextIndex);
+                        if (listStyleImage != null)
+                        {
+                            localProperties["list-style-image"] = listStyleImage;
+                        }
+                        else
+                        {
+                            // TODO: Process unrecognized list style value
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        private static string ParseCssListStyleType(string styleValue, ref int nextIndex) => ParseWordEnumeration(ListStyleTypes, styleValue, ref nextIndex);
+
+        private static string ParseCssListStylePosition(string styleValue, ref int nextIndex) => ParseWordEnumeration(ListStylePositions, styleValue, ref nextIndex);
+
+        private static string ParseCssListStyleImage(string styleValue, ref int nextIndex) => null;
+
+        private static void ParseCssTextDecoration(string styleValue, ref int nextIndex, Hashtable localProperties)
+        {
+            // Set default text-decorations:none;
+            for (var i = 1; i < TextDecorations.Length; i++)
+            {
+                localProperties["text-decoration-" + TextDecorations[i]] = "false";
+            }
+
+            // Parse list of decorations values
+            while (nextIndex < styleValue.Length)
+            {
+                var decoration = ParseWordEnumeration(TextDecorations, styleValue, ref nextIndex);
+                if (decoration == null || decoration == "none")
+                {
+                    break;
+                }
+                localProperties["text-decoration-" + decoration] = "true";
+            }
+        }
+
+        private static void ParseCssTextTransform(string styleValue, ref int nextIndex, Hashtable localProperties)
+        {
+            ParseWordEnumeration(TextTransforms, styleValue, ref nextIndex, localProperties, "text-transform");
+        }
+
+        private static void ParseCssTextAlign(string styleValue, ref int nextIndex, Hashtable localProperties)
+        {
+            ParseWordEnumeration(TextAligns, styleValue, ref nextIndex, localProperties, "text-align");
+        }
+
+        private static void ParseCssVerticalAlign(string styleValue, ref int nextIndex, Hashtable localProperties)
+        {
+            //  Parse percentage value for vertical-align style
+            ParseWordEnumeration(VerticalAligns, styleValue, ref nextIndex, localProperties, "vertical-align");
+        }
+
+        private static void ParseCssFloat(string styleValue, ref int nextIndex, Hashtable localProperties)
+        {
+            ParseWordEnumeration(Floats, styleValue, ref nextIndex, localProperties, "float");
+        }
+
+        private static void ParseCssClear(string styleValue, ref int nextIndex, Hashtable localProperties)
+        {
+            ParseWordEnumeration(Clears, styleValue, ref nextIndex, localProperties, "clear");
+        }
+
+        // .................................................................
+        //
+        // Pasring CSS margin and padding Properties
+        //
+        // .................................................................
+
+        // Generic method for parsing any of four-values properties, such as margin, padding, border-width, border-style, border-color
+        private static bool ParseCssRectangleProperty(string styleValue, ref int nextIndex, Hashtable localProperties,
+            string propertyName)
+        {
+            // CSS Spec: 
+            // If only one value is set, then the value applies to all four sides;
+            // If two or three values are set, then missinng value(s) are taken fromm the opposite side(s).
+            // The order they are applied is: top/right/bottom/left
+
+            Debug.Assert(propertyName == "margin" || propertyName == "padding" || propertyName == "border-width" ||
+                         propertyName == "border-style" || propertyName == "border-color");
+
+            var value = propertyName == "border-color"
+                ? ParseCssColor(styleValue, ref nextIndex)
+                : propertyName == "border-style"
+                    ? ParseCssBorderStyle(styleValue, ref nextIndex)
+                    : ParseCssSize(styleValue, ref nextIndex, /*mustBeNonNegative:*/true);
+            if (value != null)
+            {
+                localProperties[propertyName + "-top"] = value;
+                localProperties[propertyName + "-bottom"] = value;
+                localProperties[propertyName + "-right"] = value;
+                localProperties[propertyName + "-left"] = value;
+                value = propertyName == "border-color"
+                    ? ParseCssColor(styleValue, ref nextIndex)
+                    : propertyName == "border-style"
+                        ? ParseCssBorderStyle(styleValue, ref nextIndex)
+                        : ParseCssSize(styleValue, ref nextIndex, /*mustBeNonNegative:*/true);
+                if (value != null)
+                {
+                    localProperties[propertyName + "-right"] = value;
+                    localProperties[propertyName + "-left"] = value;
+                    value = propertyName == "border-color"
+                        ? ParseCssColor(styleValue, ref nextIndex)
+                        : propertyName == "border-style"
+                            ? ParseCssBorderStyle(styleValue, ref nextIndex)
+                            : ParseCssSize(styleValue, ref nextIndex, /*mustBeNonNegative:*/true);
+                    if (value != null)
+                    {
+                        localProperties[propertyName + "-bottom"] = value;
+                        value = propertyName == "border-color"
+                            ? ParseCssColor(styleValue, ref nextIndex)
+                            : propertyName == "border-style"
+                                ? ParseCssBorderStyle(styleValue, ref nextIndex)
+                                : ParseCssSize(styleValue, ref nextIndex, /*mustBeNonNegative:*/true);
+                        if (value != null)
+                        {
+                            localProperties[propertyName + "-left"] = value;
+                        }
+                    }
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        // .................................................................
+        //
+        // Pasring CSS border Properties
+        //
+        // .................................................................
+
+        // border: [ <border-width> || <border-style> || <border-color> ]
+
+        private static void ParseCssBorder(string styleValue, ref int nextIndex, Hashtable localProperties)
+        {
+            while (
+                ParseCssRectangleProperty(styleValue, ref nextIndex, localProperties, "border-width") ||
+                ParseCssRectangleProperty(styleValue, ref nextIndex, localProperties, "border-style") ||
+                ParseCssRectangleProperty(styleValue, ref nextIndex, localProperties, "border-color"))
+            {
+            }
+        }
+
+        private static string ParseCssBorderStyle(string styleValue, ref int nextIndex) => ParseWordEnumeration(BorderStyles, styleValue, ref nextIndex);
+
+        // .................................................................
+        //
+        // Pasring CSS Background Properties
+        //
+        // .................................................................
+
+        private static void ParseCssBackground(string styleValue, ref int nextIndex, Hashtable localValues)
+        {
+            //  Implement parsing background attribute
+        }
+    }
+}
diff --git a/MedLaunch/Classes/HtmlToXaml/HtmlLexicalAnalyzer.cs b/MedLaunch/Classes/HtmlToXaml/HtmlLexicalAnalyzer.cs
new file mode 100644
index 0000000..50d8dee
--- /dev/null
+++ b/MedLaunch/Classes/HtmlToXaml/HtmlLexicalAnalyzer.cs
@@ -0,0 +1,744 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Text;
+
+namespace MedLaunch.Classes.HtmlToXaml
+{
+    /// <summary>
+    ///     lexical analyzer class
+    ///     recognizes tokens as groups of characters separated by arbitrary amounts of whitespace
+    ///     also classifies tokens according to type
+    /// </summary>
+    internal class HtmlLexicalAnalyzer
+    {
+        // ---------------------------------------------------------------------
+        //
+        // Constructors
+        //
+        // ---------------------------------------------------------------------
+
+        #region Constructors
+
+        /// <summary>
+        ///     initializes the _inputStringReader member with the string to be read
+        ///     also sets initial values for _nextCharacterCode and _nextTokenType
+        /// </summary>
+        /// <param name="inputTextString">
+        ///     text string to be parsed for xml content
+        /// </param>
+        internal HtmlLexicalAnalyzer(string inputTextString)
+        {
+            _inputStringReader = new StringReader(inputTextString);
+            _nextCharacterCode = 0;
+            NextCharacter = ' ';
+            _lookAheadCharacterCode = _inputStringReader.Read();
+            _lookAheadCharacter = (char)_lookAheadCharacterCode;
+            _previousCharacter = ' ';
+            _ignoreNextWhitespace = true;
+            _nextToken = new StringBuilder(100);
+            NextTokenType = HtmlTokenType.Text;
+            // read the first character so we have some value for the NextCharacter property
+            GetNextCharacter();
+        }
+
+        #endregion Constructors
+
+        // ---------------------------------------------------------------------
+        //
+        // Internal methods
+        //
+        // ---------------------------------------------------------------------
+
+        #region Internal Methods
+
+        /// <summary>
+        ///     retrieves next recognizable token from input string
+        ///     and identifies its type
+        ///     if no valid token is found, the output parameters are set to null
+        ///     if end of stream is reached without matching any token, token type
+        ///     paramter is set to EOF
+        /// </summary>
+        internal void GetNextContentToken()
+        {
+            Debug.Assert(NextTokenType != HtmlTokenType.Eof);
+            _nextToken.Length = 0;
+            if (IsAtEndOfStream)
+            {
+                NextTokenType = HtmlTokenType.Eof;
+                return;
+            }
+
+            if (IsAtTagStart)
+            {
+                GetNextCharacter();
+
+                if (NextCharacter == '/')
+                {
+                    _nextToken.Append("</");
+                    NextTokenType = HtmlTokenType.ClosingTagStart;
+
+                    // advance
+                    GetNextCharacter();
+                    _ignoreNextWhitespace = false; // Whitespaces after closing tags are significant
+                }
+                else
+                {
+                    NextTokenType = HtmlTokenType.OpeningTagStart;
+                    _nextToken.Append("<");
+                    _ignoreNextWhitespace = true; // Whitespaces after opening tags are insignificant
+                }
+            }
+            else if (IsAtDirectiveStart)
+            {
+                // either a comment or CDATA
+                GetNextCharacter();
+                if (_lookAheadCharacter == '[')
+                {
+                    // cdata
+                    ReadDynamicContent();
+                }
+                else if (_lookAheadCharacter == '-')
+                {
+                    ReadComment();
+                }
+                else
+                {
+                    // neither a comment nor cdata, should be something like DOCTYPE
+                    // skip till the next tag ender
+                    ReadUnknownDirective();
+                }
+            }
+            else
+            {
+                // read text content, unless you encounter a tag
+                NextTokenType = HtmlTokenType.Text;
+                while (!IsAtTagStart && !IsAtEndOfStream && !IsAtDirectiveStart)
+                {
+                    if (NextCharacter == '<' && !IsNextCharacterEntity && _lookAheadCharacter == '?')
+                    {
+                        // ignore processing directive
+                        SkipProcessingDirective();
+                    }
+                    else
+                    {
+                        if (NextCharacter <= ' ')
+                        {
+                            //  Respect xml:preserve or its equivalents for whitespace processing
+                            if (_ignoreNextWhitespace)
+                            {
+                                // Ignore repeated whitespaces
+                            }
+                            else
+                            {
+                                // Treat any control character sequence as one whitespace
+                                _nextToken.Append(' ');
+                            }
+                            _ignoreNextWhitespace = true; // and keep ignoring the following whitespaces
+                        }
+                        else
+                        {
+                            _nextToken.Append(NextCharacter);
+                            _ignoreNextWhitespace = false;
+                        }
+                        GetNextCharacter();
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Unconditionally returns a token which is one of: TagEnd, EmptyTagEnd, Name, Atom or EndOfStream
+        ///     Does not guarantee token reader advancing.
+        /// </summary>
+        internal void GetNextTagToken()
+        {
+            _nextToken.Length = 0;
+            if (IsAtEndOfStream)
+            {
+                NextTokenType = HtmlTokenType.Eof;
+                return;
+            }
+
+            SkipWhiteSpace();
+
+            if (NextCharacter == '>' && !IsNextCharacterEntity)
+            {
+                // &gt; should not end a tag, so make sure it's not an entity
+                NextTokenType = HtmlTokenType.TagEnd;
+                _nextToken.Append('>');
+                GetNextCharacter();
+                // Note: _ignoreNextWhitespace must be set appropriately on tag start processing
+            }
+            else if (NextCharacter == '/' && _lookAheadCharacter == '>')
+            {
+                // could be start of closing of empty tag
+                NextTokenType = HtmlTokenType.EmptyTagEnd;
+                _nextToken.Append("/>");
+                GetNextCharacter();
+                GetNextCharacter();
+                _ignoreNextWhitespace = false; // Whitespace after no-scope tags are sifnificant
+            }
+            else if (IsGoodForNameStart(NextCharacter))
+            {
+                NextTokenType = HtmlTokenType.Name;
+
+                // starts a name
+                // we allow character entities here
+                // we do not throw exceptions here if end of stream is encountered
+                // just stop and return whatever is in the token
+                // if the parser is not expecting end of file after this it will call
+                // the get next token function and throw an exception
+                while (IsGoodForName(NextCharacter) && !IsAtEndOfStream)
+                {
+                    _nextToken.Append(NextCharacter);
+                    GetNextCharacter();
+                }
+            }
+            else
+            {
+                // Unexpected type of token for a tag. Reprot one character as Atom, expecting that HtmlParser will ignore it.
+                NextTokenType = HtmlTokenType.Atom;
+                _nextToken.Append(NextCharacter);
+                GetNextCharacter();
+            }
+        }
+
+        /// <summary>
+        ///     Unconditionally returns equal sign token. Even if there is no
+        ///     real equal sign in the stream, it behaves as if it were there.
+        ///     Does not guarantee token reader advancing.
+        /// </summary>
+        internal void GetNextEqualSignToken()
+        {
+            Debug.Assert(NextTokenType != HtmlTokenType.Eof);
+            _nextToken.Length = 0;
+
+            _nextToken.Append('=');
+            NextTokenType = HtmlTokenType.EqualSign;
+
+            SkipWhiteSpace();
+
+            if (NextCharacter == '=')
+            {
+                // '=' is not in the list of entities, so no need to check for entities here
+                GetNextCharacter();
+            }
+        }
+
+        /// <summary>
+        ///     Unconditionally returns an atomic value for an attribute
+        ///     Even if there is no appropriate token it returns Atom value
+        ///     Does not guarantee token reader advancing.
+        /// </summary>
+        internal void GetNextAtomToken()
+        {
+            Debug.Assert(NextTokenType != HtmlTokenType.Eof);
+            _nextToken.Length = 0;
+
+            SkipWhiteSpace();
+
+            NextTokenType = HtmlTokenType.Atom;
+
+            if ((NextCharacter == '\'' || NextCharacter == '"') && !IsNextCharacterEntity)
+            {
+                var startingQuote = NextCharacter;
+                GetNextCharacter();
+
+                // Consume all characters between quotes
+                while (!(NextCharacter == startingQuote && !IsNextCharacterEntity) && !IsAtEndOfStream)
+                {
+                    _nextToken.Append(NextCharacter);
+                    GetNextCharacter();
+                }
+                if (NextCharacter == startingQuote)
+                {
+                    GetNextCharacter();
+                }
+
+                // complete the quoted value
+                // NOTE: our recovery here is different from IE's
+                // IE keeps reading until it finds a closing quote or end of file
+                // if end of file, it treats current value as text
+                // if it finds a closing quote at any point within the text, it eats everything between the quotes
+                // TODO: Suggestion:
+                // however, we could stop when we encounter end of file or an angle bracket of any kind
+                // and assume there was a quote there
+                // so the attribute value may be meaningless but it is never treated as text
+            }
+            else
+            {
+                while (!IsAtEndOfStream && !char.IsWhiteSpace(NextCharacter) && NextCharacter != '>')
+                {
+                    _nextToken.Append(NextCharacter);
+                    GetNextCharacter();
+                }
+            }
+        }
+
+        #endregion Internal Methods
+
+        // ---------------------------------------------------------------------
+        //
+        // Internal Properties
+        //
+        // ---------------------------------------------------------------------
+
+        #region Internal Properties
+
+        internal HtmlTokenType NextTokenType { get; private set; }
+
+        internal string NextToken => _nextToken.ToString();
+
+        #endregion Internal Properties
+
+        // ---------------------------------------------------------------------
+        //
+        // Private methods
+        //
+        // ---------------------------------------------------------------------
+
+        #region Private Methods
+
+        /// <summary>
+        ///     Advances a reading position by one character code
+        ///     and reads the next availbale character from a stream.
+        ///     This character becomes available as NextCharacter property.
+        /// </summary>
+        /// <remarks>
+        ///     Throws InvalidOperationException if attempted to be called on EndOfStream
+        ///     condition.
+        /// </remarks>
+        private void GetNextCharacter()
+        {
+            if (_nextCharacterCode == -1)
+            {
+                throw new InvalidOperationException("GetNextCharacter method called at the end of a stream");
+            }
+
+            _previousCharacter = NextCharacter;
+
+            NextCharacter = _lookAheadCharacter;
+            _nextCharacterCode = _lookAheadCharacterCode;
+            // next character not an entity as of now
+            IsNextCharacterEntity = false;
+
+            ReadLookAheadCharacter();
+
+            if (NextCharacter == '&')
+            {
+                if (_lookAheadCharacter == '#')
+                {
+                    // numeric entity - parse digits - &#DDDDD;
+                    int entityCode;
+                    entityCode = 0;
+                    ReadLookAheadCharacter();
+
+                    // largest numeric entity is 7 characters
+                    for (var i = 0; i < 7 && char.IsDigit(_lookAheadCharacter); i++)
+                    {
+                        entityCode = 10 * entityCode + (_lookAheadCharacterCode - '0');
+                        ReadLookAheadCharacter();
+                    }
+                    if (_lookAheadCharacter == ';')
+                    {
+                        // correct format - advance
+                        ReadLookAheadCharacter();
+                        _nextCharacterCode = entityCode;
+
+                        // if this is out of range it will set the character to '?'
+                        NextCharacter = (char)_nextCharacterCode;
+
+                        // as far as we are concerned, this is an entity
+                        IsNextCharacterEntity = true;
+                    }
+                    else
+                    {
+                        // not an entity, set next character to the current lookahread character
+                        // we would have eaten up some digits
+                        NextCharacter = _lookAheadCharacter;
+                        _nextCharacterCode = _lookAheadCharacterCode;
+                        ReadLookAheadCharacter();
+                        IsNextCharacterEntity = false;
+                    }
+                }
+                else if (char.IsLetter(_lookAheadCharacter))
+                {
+                    // entity is written as a string
+                    var entity = "";
+
+                    // maximum length of string entities is 10 characters
+                    for (var i = 0;
+                        i < 10 && (char.IsLetter(_lookAheadCharacter) || char.IsDigit(_lookAheadCharacter));
+                        i++)
+                    {
+                        entity += _lookAheadCharacter;
+                        ReadLookAheadCharacter();
+                    }
+                    if (_lookAheadCharacter == ';')
+                    {
+                        // advance
+                        ReadLookAheadCharacter();
+
+                        if (HtmlSchema.IsEntity(entity))
+                        {
+                            NextCharacter = HtmlSchema.EntityCharacterValue(entity);
+                            _nextCharacterCode = NextCharacter;
+                            IsNextCharacterEntity = true;
+                        }
+                        else
+                        {
+                            // just skip the whole thing - invalid entity
+                            // move on to the next character
+                            NextCharacter = _lookAheadCharacter;
+                            _nextCharacterCode = _lookAheadCharacterCode;
+                            ReadLookAheadCharacter();
+
+                            // not an entity
+                            IsNextCharacterEntity = false;
+                        }
+                    }
+                    else
+                    {
+                        // skip whatever we read after the ampersand
+                        // set next character and move on
+                        NextCharacter = _lookAheadCharacter;
+                        ReadLookAheadCharacter();
+                        IsNextCharacterEntity = false;
+                    }
+                }
+            }
+        }
+
+        private void ReadLookAheadCharacter()
+        {
+            if (_lookAheadCharacterCode != -1)
+            {
+                _lookAheadCharacterCode = _inputStringReader.Read();
+                _lookAheadCharacter = (char)_lookAheadCharacterCode;
+            }
+        }
+
+        /// <summary>
+        ///     skips whitespace in the input string
+        ///     leaves the first non-whitespace character available in the NextCharacter property
+        ///     this may be the end-of-file character, it performs no checking
+        /// </summary>
+        private void SkipWhiteSpace()
+        {
+            // TODO: handle character entities while processing comments, cdata, and directives
+            // TODO: SUGGESTION: we could check if lookahead and previous characters are entities also
+            while (true)
+            {
+                if (NextCharacter == '<' && (_lookAheadCharacter == '?' || _lookAheadCharacter == '!'))
+                {
+                    GetNextCharacter();
+
+                    if (_lookAheadCharacter == '[')
+                    {
+                        // Skip CDATA block and DTDs(?)
+                        while (!IsAtEndOfStream &&
+                               !(_previousCharacter == ']' && NextCharacter == ']' && _lookAheadCharacter == '>'))
+                        {
+                            GetNextCharacter();
+                        }
+                        if (NextCharacter == '>')
+                        {
+                            GetNextCharacter();
+                        }
+                    }
+                    else
+                    {
+                        // Skip processing instruction, comments
+                        while (!IsAtEndOfStream && NextCharacter != '>')
+                        {
+                            GetNextCharacter();
+                        }
+                        if (NextCharacter == '>')
+                        {
+                            GetNextCharacter();
+                        }
+                    }
+                }
+
+
+                if (!char.IsWhiteSpace(NextCharacter))
+                {
+                    break;
+                }
+
+                GetNextCharacter();
+            }
+        }
+
+        /// <summary>
+        ///     checks if a character can be used to start a name
+        ///     if this check is true then the rest of the name can be read
+        /// </summary>
+        /// <param name="character">
+        ///     character value to be checked
+        /// </param>
+        /// <returns>
+        ///     true if the character can be the first character in a name
+        ///     false otherwise
+        /// </returns>
+        private bool IsGoodForNameStart(char character) => character == '_' || char.IsLetter(character);
+
+        /// <summary>
+        ///     checks if a character can be used as a non-starting character in a name
+        ///     uses the IsExtender and IsCombiningCharacter predicates to see
+        ///     if a character is an extender or a combining character
+        /// </summary>
+        /// <param name="character">
+        ///     character to be checked for validity in a name
+        /// </param>
+        /// <returns>
+        ///     true if the character can be a valid part of a name
+        /// </returns>
+        private bool IsGoodForName(char character) => IsGoodForNameStart(character) ||
+                character == '.' ||
+                character == '-' ||
+                character == ':' ||
+                char.IsDigit(character) ||
+                IsCombiningCharacter(character) ||
+                IsExtender(character);
+
+        /// <summary>
+        ///     identifies a character as being a combining character, permitted in a name
+        ///     TODO: only a placeholder for now but later to be replaced with comparisons against
+        ///     the list of combining characters in the XML documentation
+        /// </summary>
+        /// <param name="character">
+        ///     character to be checked
+        /// </param>
+        /// <returns>
+        ///     true if the character is a combining character, false otherwise
+        /// </returns>
+        private bool IsCombiningCharacter(char character) => false;
+
+        /// <summary>
+        ///     identifies a character as being an extender, permitted in a name
+        ///     TODO: only a placeholder for now but later to be replaced with comparisons against
+        ///     the list of extenders in the XML documentation
+        /// </summary>
+        /// <param name="character">
+        ///     character to be checked
+        /// </param>
+        /// <returns>
+        ///     true if the character is an extender, false otherwise
+        /// </returns>
+        private bool IsExtender(char character) => false;
+
+        /// <summary>
+        ///     skips dynamic content starting with '<![' and ending with ']>'
+        /// </summary>
+        private void ReadDynamicContent()
+        {
+            // verify that we are at dynamic content, which may include CDATA
+            Debug.Assert(_previousCharacter == '<' && NextCharacter == '!' && _lookAheadCharacter == '[');
+
+            // Let's treat this as empty text
+            NextTokenType = HtmlTokenType.Text;
+            _nextToken.Length = 0;
+
+            // advance twice, once to get the lookahead character and then to reach the start of the cdata
+            GetNextCharacter();
+            GetNextCharacter();
+
+            // NOTE: 10/12/2004: modified this function to check when called if's reading CDATA or something else
+            // some directives may start with a <![ and then have some data and they will just end with a ]>
+            // this function is modified to stop at the sequence ]> and not ]]>
+            // this means that CDATA and anything else expressed in their own set of [] within the <! [...]>
+            // directive cannot contain a ]> sequence. However it is doubtful that cdata could contain such
+            // sequence anyway, it probably stops at the first ]
+            while (!(NextCharacter == ']' && _lookAheadCharacter == '>') && !IsAtEndOfStream)
+            {
+                // advance
+                GetNextCharacter();
+            }
+
+            if (!IsAtEndOfStream)
+            {
+                // advance, first to the last >
+                GetNextCharacter();
+
+                // then advance past it to the next character after processing directive
+                GetNextCharacter();
+            }
+        }
+
+        /// <summary>
+        ///     skips comments starting with '<!-' and ending with '-->'
+        ///     NOTE: 10/06/2004: processing changed, will now skip anything starting with
+        ///     the "<!-"  sequence and ending in "!>" or "->", because in practice many html pages do not
+        ///     use the full comment specifying conventions
+        /// </summary>
+        private void ReadComment()
+        {
+            // verify that we are at a comment
+            Debug.Assert(_previousCharacter == '<' && NextCharacter == '!' && _lookAheadCharacter == '-');
+
+            // Initialize a token
+            NextTokenType = HtmlTokenType.Comment;
+            _nextToken.Length = 0;
+
+            // advance to the next character, so that to be at the start of comment value
+            GetNextCharacter(); // get first '-'
+            GetNextCharacter(); // get second '-'
+            GetNextCharacter(); // get first character of comment content
+
+            while (true)
+            {
+                // Read text until end of comment
+                // Note that in many actual html pages comments end with "!>" (while xml standard is "-->")
+                while (!IsAtEndOfStream &&
+                       !(NextCharacter == '-' && _lookAheadCharacter == '-' ||
+                         NextCharacter == '!' && _lookAheadCharacter == '>'))
+                {
+                    _nextToken.Append(NextCharacter);
+                    GetNextCharacter();
+                }
+
+                // Finish comment reading
+                GetNextCharacter();
+                if (_previousCharacter == '-' && NextCharacter == '-' && _lookAheadCharacter == '>')
+                {
+                    // Standard comment end. Eat it and exit the loop
+                    GetNextCharacter(); // get '>'
+                    break;
+                }
+                if (_previousCharacter == '!' && NextCharacter == '>')
+                {
+                    // Nonstandard but possible comment end - '!>'. Exit the loop
+                    break;
+                }
+                // Not an end. Save character and continue continue reading
+                _nextToken.Append(_previousCharacter);
+            }
+
+            // Read end of comment combination
+            if (NextCharacter == '>')
+            {
+                GetNextCharacter();
+            }
+        }
+
+        /// <summary>
+        ///     skips past unknown directives that start with "<!" but are not comments or Cdata
+        /// ignores content of such directives until the next ">"
+        ///     character
+        ///     applies to directives such as DOCTYPE, etc that we do not presently support
+        /// </summary>
+        private void ReadUnknownDirective()
+        {
+            // verify that we are at an unknown directive
+            Debug.Assert(_previousCharacter == '<' && NextCharacter == '!' &&
+                         !(_lookAheadCharacter == '-' || _lookAheadCharacter == '['));
+
+            // Let's treat this as empty text
+            NextTokenType = HtmlTokenType.Text;
+            _nextToken.Length = 0;
+
+            // advance to the next character
+            GetNextCharacter();
+
+            // skip to the first tag end we find
+            while (!(NextCharacter == '>' && !IsNextCharacterEntity) && !IsAtEndOfStream)
+            {
+                GetNextCharacter();
+            }
+
+            if (!IsAtEndOfStream)
+            {
+                // advance past the tag end
+                GetNextCharacter();
+            }
+        }
+
+        /// <summary>
+        ///     skips processing directives starting with the characters '<?' and ending with '?>'
+        ///     NOTE: 10/14/2004: IE also ends processing directives with a />, so this function is
+        ///     being modified to recognize that condition as well
+        /// </summary>
+        private void SkipProcessingDirective()
+        {
+            // verify that we are at a processing directive
+            Debug.Assert(NextCharacter == '<' && _lookAheadCharacter == '?');
+
+            // advance twice, once to get the lookahead character and then to reach the start of the drective
+            GetNextCharacter();
+            GetNextCharacter();
+
+            while (!((NextCharacter == '?' || NextCharacter == '/') && _lookAheadCharacter == '>') && !IsAtEndOfStream)
+            {
+                // advance
+                // we don't need to check for entities here because '?' is not an entity
+                // and even though > is an entity there is no entity processing when reading lookahead character
+                GetNextCharacter();
+            }
+
+            if (!IsAtEndOfStream)
+            {
+                // advance, first to the last >
+                GetNextCharacter();
+
+                // then advance past it to the next character after processing directive
+                GetNextCharacter();
+            }
+        }
+
+        #endregion Private Methods
+
+        // ---------------------------------------------------------------------
+        //
+        // Private Properties
+        //
+        // ---------------------------------------------------------------------
+
+        #region Private Properties
+
+        private char NextCharacter { get; set; }
+
+        private bool IsAtEndOfStream => _nextCharacterCode == -1;
+
+        private bool IsAtTagStart
+            => NextCharacter == '<' && (_lookAheadCharacter == '/' || IsGoodForNameStart(_lookAheadCharacter)) &&
+               !IsNextCharacterEntity;
+
+        private bool IsAtTagEnd => (NextCharacter == '>' || (NextCharacter == '/' && _lookAheadCharacter == '>')) &&
+                                   !IsNextCharacterEntity;
+
+        private bool IsAtDirectiveStart
+            => (NextCharacter == '<' && _lookAheadCharacter == '!' && !IsNextCharacterEntity);
+
+        private bool IsNextCharacterEntity
+        { // check if next character is an entity
+            get; set;
+        }
+
+        #endregion Private Properties
+
+        // ---------------------------------------------------------------------
+        //
+        // Private Fields
+        //
+        // ---------------------------------------------------------------------
+
+        #region Private Fields
+
+        // string reader which will move over input text
+        private readonly StringReader _inputStringReader;
+        // next character code read from input that is not yet part of any token
+        // and the character it represents
+        private int _nextCharacterCode;
+        private int _lookAheadCharacterCode;
+        private char _lookAheadCharacter;
+        private char _previousCharacter;
+        private bool _ignoreNextWhitespace;
+
+        // store token and type in local variables before copying them to output parameters
+        private readonly StringBuilder _nextToken;
+
+        #endregion Private Fields
+    }
+}
diff --git a/MedLaunch/Classes/HtmlToXaml/HtmlParser.cs b/MedLaunch/Classes/HtmlToXaml/HtmlParser.cs
new file mode 100644
index 0000000..e672d84
--- /dev/null
+++ b/MedLaunch/Classes/HtmlToXaml/HtmlParser.cs
@@ -0,0 +1,483 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml;
+
+namespace MedLaunch.Classes.HtmlToXaml
+{
+    /// <summary>
+    ///     HtmlParser class accepts a string of possibly badly formed Html, parses it and returns a string
+    ///     of well-formed Html that is as close to the original string in content as possible
+    /// </summary>
+    internal class HtmlParser
+    {
+        // ---------------------------------------------------------------------
+        //
+        // Constructors
+        //
+        // ---------------------------------------------------------------------
+
+        #region Constructors
+
+        /// <summary>
+        ///     Constructor. Initializes the _htmlLexicalAnalayzer element with the given input string
+        /// </summary>
+        /// <param name="inputString">
+        ///     string to parsed into well-formed Html
+        /// </param>
+        private HtmlParser(string inputString)
+        {
+            // Create an output xml document
+            _document = new XmlDocument();
+
+            // initialize open tag stack
+            _openedElements = new Stack<XmlElement>();
+
+            _pendingInlineElements = new Stack<XmlElement>();
+
+            // initialize lexical analyzer
+            _htmlLexicalAnalyzer = new HtmlLexicalAnalyzer(inputString);
+
+            // get first token from input, expecting text
+            _htmlLexicalAnalyzer.GetNextContentToken();
+        }
+
+        #endregion Constructors
+
+        // ---------------------------------------------------------------------
+        //
+        // Internal Methods
+        //
+        // ---------------------------------------------------------------------
+
+        #region Internal Methods
+
+        /// <summary>
+        ///     Instantiates an HtmlParser element and calls the parsing function on the given input string
+        /// </summary>
+        /// <param name="htmlString">
+        ///     Input string of pssibly badly-formed Html to be parsed into well-formed Html
+        /// </param>
+        /// <returns>
+        ///     XmlElement rep
+        /// </returns>
+        internal static XmlElement ParseHtml(string htmlString)
+        {
+            var htmlParser = new HtmlParser(htmlString);
+
+            var htmlRootElement = htmlParser.ParseHtmlContent();
+
+            return htmlRootElement;
+        }
+
+        // .....................................................................
+        //
+        // Html Header on Clipboard
+        //
+        // .....................................................................
+
+        // Html header structure.
+        //      Version:1.0
+        //      StartHTML:000000000
+        //      EndHTML:000000000
+        //      StartFragment:000000000
+        //      EndFragment:000000000
+        //      StartSelection:000000000
+        //      EndSelection:000000000
+        internal const string HtmlHeader =
+            "Version:1.0\r\nStartHTML:{0:D10}\r\nEndHTML:{1:D10}\r\nStartFragment:{2:D10}\r\nEndFragment:{3:D10}\r\nStartSelection:{4:D10}\r\nEndSelection:{5:D10}\r\n";
+
+        internal const string HtmlStartFragmentComment = "<!--StartFragment-->";
+        internal const string HtmlEndFragmentComment = "<!--EndFragment-->";
+
+        /// <summary>
+        ///     Extracts Html string from clipboard data by parsing header information in htmlDataString
+        /// </summary>
+        /// <param name="htmlDataString">
+        ///     String representing Html clipboard data. This includes Html header
+        /// </param>
+        /// <returns>
+        ///     String containing only the Html data part of htmlDataString, without header
+        /// </returns>
+        internal static string ExtractHtmlFromClipboardData(string htmlDataString)
+        {
+            var startHtmlIndex = htmlDataString.IndexOf("StartHTML:", StringComparison.Ordinal);
+            if (startHtmlIndex < 0)
+            {
+                return "ERROR: Urecognized html header";
+            }
+            // TODO: We assume that indices represented by strictly 10 zeros ("0123456789".Length),
+            // which could be wrong assumption. We need to implement more flrxible parsing here
+            startHtmlIndex =
+                int.Parse(htmlDataString.Substring(startHtmlIndex + "StartHTML:".Length, "0123456789".Length));
+            if (startHtmlIndex < 0 || startHtmlIndex > htmlDataString.Length)
+            {
+                return "ERROR: Urecognized html header";
+            }
+
+            var endHtmlIndex = htmlDataString.IndexOf("EndHTML:", StringComparison.Ordinal);
+            if (endHtmlIndex < 0)
+            {
+                return "ERROR: Urecognized html header";
+            }
+            // TODO: We assume that indices represented by strictly 10 zeros ("0123456789".Length),
+            // which could be wrong assumption. We need to implement more flrxible parsing here
+            endHtmlIndex = int.Parse(htmlDataString.Substring(endHtmlIndex + "EndHTML:".Length, "0123456789".Length));
+            if (endHtmlIndex > htmlDataString.Length)
+            {
+                endHtmlIndex = htmlDataString.Length;
+            }
+
+            return htmlDataString.Substring(startHtmlIndex, endHtmlIndex - startHtmlIndex);
+        }
+
+        /// <summary>
+        ///     Adds Xhtml header information to Html data string so that it can be placed on clipboard
+        /// </summary>
+        /// <param name="htmlString">
+        ///     Html string to be placed on clipboard with appropriate header
+        /// </param>
+        /// <returns>
+        ///     String wrapping htmlString with appropriate Html header
+        /// </returns>
+        internal static string AddHtmlClipboardHeader(string htmlString)
+        {
+            var stringBuilder = new StringBuilder();
+
+            // each of 6 numbers is represented by "{0:D10}" in the format string
+            // must actually occupy 10 digit positions ("0123456789")
+            var startHtml = HtmlHeader.Length + 6 * ("0123456789".Length - "{0:D10}".Length);
+            var endHtml = startHtml + htmlString.Length;
+            var startFragment = htmlString.IndexOf(HtmlStartFragmentComment, 0, StringComparison.Ordinal);
+            if (startFragment >= 0)
+            {
+                startFragment = startHtml + startFragment + HtmlStartFragmentComment.Length;
+            }
+            else
+            {
+                startFragment = startHtml;
+            }
+            var endFragment = htmlString.IndexOf(HtmlEndFragmentComment, 0, StringComparison.Ordinal);
+            if (endFragment >= 0)
+            {
+                endFragment = startHtml + endFragment;
+            }
+            else
+            {
+                endFragment = endHtml;
+            }
+
+            // Create HTML clipboard header string
+            stringBuilder.AppendFormat(HtmlHeader, startHtml, endHtml, startFragment, endFragment, startFragment,
+                endFragment);
+
+            // Append HTML body.
+            stringBuilder.Append(htmlString);
+
+            return stringBuilder.ToString();
+        }
+
+        #endregion Internal Methods
+
+        // ---------------------------------------------------------------------
+        //
+        // Private methods
+        //
+        // ---------------------------------------------------------------------
+
+        #region Private Methods
+
+        private void InvariantAssert(bool condition, string message)
+        {
+            if (!condition)
+            {
+                throw new Exception("Assertion error: " + message);
+            }
+        }
+
+        /// <summary>
+        ///     Parses the stream of html tokens starting
+        ///     from the name of top-level element.
+        ///     Returns XmlElement representing the top-level
+        ///     html element
+        /// </summary>
+        private XmlElement ParseHtmlContent()
+        {
+            // Create artificial root elelemt to be able to group multiple top-level elements
+            // We create "html" element which may be a duplicate of real HTML element, which is ok, as HtmlConverter will swallow it painlessly..
+            var htmlRootElement = _document.CreateElement("html", XhtmlNamespace);
+            OpenStructuringElement(htmlRootElement);
+
+            while (_htmlLexicalAnalyzer.NextTokenType != HtmlTokenType.Eof)
+            {
+                if (_htmlLexicalAnalyzer.NextTokenType == HtmlTokenType.OpeningTagStart)
+                {
+                    _htmlLexicalAnalyzer.GetNextTagToken();
+                    if (_htmlLexicalAnalyzer.NextTokenType == HtmlTokenType.Name)
+                    {
+                        var htmlElementName = _htmlLexicalAnalyzer.NextToken.ToLower();
+                        _htmlLexicalAnalyzer.GetNextTagToken();
+
+                        // Create an element
+                        var htmlElement = _document.CreateElement(htmlElementName, XhtmlNamespace);
+
+                        // Parse element attributes
+                        ParseAttributes(htmlElement);
+
+                        if (_htmlLexicalAnalyzer.NextTokenType == HtmlTokenType.EmptyTagEnd ||
+                            HtmlSchema.IsEmptyElement(htmlElementName))
+                        {
+                            // It is an element without content (because of explicit slash or based on implicit knowledge aboout html)
+                            AddEmptyElement(htmlElement);
+                        }
+                        else if (HtmlSchema.IsInlineElement(htmlElementName))
+                        {
+                            // Elements known as formatting are pushed to some special
+                            // pending stack, which allows them to be transferred
+                            // over block tags - by doing this we convert
+                            // overlapping tags into normal heirarchical element structure.
+                            OpenInlineElement(htmlElement);
+                        }
+                        else if (HtmlSchema.IsBlockElement(htmlElementName) ||
+                                 HtmlSchema.IsKnownOpenableElement(htmlElementName))
+                        {
+                            // This includes no-scope elements
+                            OpenStructuringElement(htmlElement);
+                        }
+                    }
+                }
+                else if (_htmlLexicalAnalyzer.NextTokenType == HtmlTokenType.ClosingTagStart)
+                {
+                    _htmlLexicalAnalyzer.GetNextTagToken();
+                    if (_htmlLexicalAnalyzer.NextTokenType == HtmlTokenType.Name)
+                    {
+                        var htmlElementName = _htmlLexicalAnalyzer.NextToken.ToLower();
+
+                        // Skip the name token. Assume that the following token is end of tag,
+                        // but do not check this. If it is not true, we simply ignore one token
+                        // - this is our recovery from bad xml in this case.
+                        _htmlLexicalAnalyzer.GetNextTagToken();
+
+                        CloseElement(htmlElementName);
+                    }
+                }
+                else if (_htmlLexicalAnalyzer.NextTokenType == HtmlTokenType.Text)
+                {
+                    AddTextContent(_htmlLexicalAnalyzer.NextToken);
+                }
+                else if (_htmlLexicalAnalyzer.NextTokenType == HtmlTokenType.Comment)
+                {
+                    AddComment(_htmlLexicalAnalyzer.NextToken);
+                }
+
+                _htmlLexicalAnalyzer.GetNextContentToken();
+            }
+
+            // Get rid of the artificial root element
+            if (htmlRootElement.FirstChild is XmlElement &&
+                htmlRootElement.FirstChild == htmlRootElement.LastChild &&
+                htmlRootElement.FirstChild.LocalName.ToLower() == "html")
+            {
+                htmlRootElement = (XmlElement)htmlRootElement.FirstChild;
+            }
+
+            return htmlRootElement;
+        }
+
+        private XmlElement CreateElementCopy(XmlElement htmlElement)
+        {
+            var htmlElementCopy = _document.CreateElement(htmlElement.LocalName, XhtmlNamespace);
+            for (var i = 0; i < htmlElement.Attributes.Count; i++)
+            {
+                var attribute = htmlElement.Attributes[i];
+                htmlElementCopy.SetAttribute(attribute.Name, attribute.Value);
+            }
+            return htmlElementCopy;
+        }
+
+        private void AddEmptyElement(XmlElement htmlEmptyElement)
+        {
+            InvariantAssert(_openedElements.Count > 0,
+                "AddEmptyElement: Stack of opened elements cannot be empty, as we have at least one artificial root element");
+            var htmlParent = _openedElements.Peek();
+            htmlParent.AppendChild(htmlEmptyElement);
+        }
+
+        private void OpenInlineElement(XmlElement htmlInlineElement)
+        {
+            _pendingInlineElements.Push(htmlInlineElement);
+        }
+
+        // Opens structurig element such as Div or Table etc.
+        private void OpenStructuringElement(XmlElement htmlElement)
+        {
+            // Close all pending inline elements
+            // All block elements are considered as delimiters for inline elements
+            // which forces all inline elements to be closed and re-opened in the following
+            // structural element (if any).
+            // By doing that we guarantee that all inline elements appear only within most nested blocks
+            if (HtmlSchema.IsBlockElement(htmlElement.LocalName))
+            {
+                while (_openedElements.Count > 0 && HtmlSchema.IsInlineElement(_openedElements.Peek().LocalName))
+                {
+                    var htmlInlineElement = _openedElements.Pop();
+                    InvariantAssert(_openedElements.Count > 0,
+                        "OpenStructuringElement: stack of opened elements cannot become empty here");
+
+                    _pendingInlineElements.Push(CreateElementCopy(htmlInlineElement));
+                }
+            }
+
+            // Add this block element to its parent
+            if (_openedElements.Count > 0)
+            {
+                var htmlParent = _openedElements.Peek();
+
+                // Check some known block elements for auto-closing (LI and P)
+                if (HtmlSchema.ClosesOnNextElementStart(htmlParent.LocalName, htmlElement.LocalName))
+                {
+                    _openedElements.Pop();
+                    htmlParent = _openedElements.Count > 0 ? _openedElements.Peek() : null;
+                }
+
+                // NOTE:
+                // Actually we never expect null - it would mean two top-level P or LI (without a parent).
+                // In such weird case we will loose all paragraphs except the first one...
+                htmlParent?.AppendChild(htmlElement);
+            }
+
+            // Push it onto a stack
+            _openedElements.Push(htmlElement);
+        }
+
+        private bool IsElementOpened(string htmlElementName) => _openedElements.Any(openedElement => openedElement.LocalName == htmlElementName);
+
+        private void CloseElement(string htmlElementName)
+        {
+            // Check if the element is opened and already added to the parent
+            InvariantAssert(_openedElements.Count > 0,
+                "CloseElement: Stack of opened elements cannot be empty, as we have at least one artificial root element");
+
+            // Check if the element is opened and still waiting to be added to the parent
+            if (_pendingInlineElements.Count > 0 && _pendingInlineElements.Peek().LocalName == htmlElementName)
+            {
+                // Closing an empty inline element.
+                // Note that HtmlConverter will skip empty inlines, but for completeness we keep them here on parser level.
+                var htmlInlineElement = _pendingInlineElements.Pop();
+                InvariantAssert(_openedElements.Count > 0,
+                    "CloseElement: Stack of opened elements cannot be empty, as we have at least one artificial root element");
+                var htmlParent = _openedElements.Peek();
+                htmlParent.AppendChild(htmlInlineElement);
+            }
+            else if (IsElementOpened(htmlElementName))
+            {
+                while (_openedElements.Count > 1) // we never pop the last element - the artificial root
+                {
+                    // Close all unbalanced elements.
+                    var htmlOpenedElement = _openedElements.Pop();
+
+                    if (htmlOpenedElement.LocalName == htmlElementName)
+                    {
+                        return;
+                    }
+
+                    if (HtmlSchema.IsInlineElement(htmlOpenedElement.LocalName))
+                    {
+                        // Unbalances Inlines will be transfered to the next element content
+                        _pendingInlineElements.Push(CreateElementCopy(htmlOpenedElement));
+                    }
+                }
+            }
+
+            // If element was not opened, we simply ignore the unbalanced closing tag
+        }
+
+        private void AddTextContent(string textContent)
+        {
+            OpenPendingInlineElements();
+
+            InvariantAssert(_openedElements.Count > 0,
+                "AddTextContent: Stack of opened elements cannot be empty, as we have at least one artificial root element");
+
+            var htmlParent = _openedElements.Peek();
+            var textNode = _document.CreateTextNode(textContent);
+            htmlParent.AppendChild(textNode);
+        }
+
+        private void AddComment(string comment)
+        {
+            OpenPendingInlineElements();
+
+            InvariantAssert(_openedElements.Count > 0,
+                "AddComment: Stack of opened elements cannot be empty, as we have at least one artificial root element");
+
+            var htmlParent = _openedElements.Peek();
+            var xmlComment = _document.CreateComment(comment);
+            htmlParent.AppendChild(xmlComment);
+        }
+
+        // Moves all inline elements pending for opening to actual document
+        // and adds them to current open stack.
+        private void OpenPendingInlineElements()
+        {
+            if (_pendingInlineElements.Count > 0)
+            {
+                var htmlInlineElement = _pendingInlineElements.Pop();
+
+                OpenPendingInlineElements();
+
+                InvariantAssert(_openedElements.Count > 0,
+                    "OpenPendingInlineElements: Stack of opened elements cannot be empty, as we have at least one artificial root element");
+
+                var htmlParent = _openedElements.Peek();
+                htmlParent.AppendChild(htmlInlineElement);
+                _openedElements.Push(htmlInlineElement);
+            }
+        }
+
+        private void ParseAttributes(XmlElement xmlElement)
+        {
+            while (_htmlLexicalAnalyzer.NextTokenType != HtmlTokenType.Eof && //
+                   _htmlLexicalAnalyzer.NextTokenType != HtmlTokenType.TagEnd && //
+                   _htmlLexicalAnalyzer.NextTokenType != HtmlTokenType.EmptyTagEnd)
+            {
+                // read next attribute (name=value)
+                if (_htmlLexicalAnalyzer.NextTokenType == HtmlTokenType.Name)
+                {
+                    var attributeName = _htmlLexicalAnalyzer.NextToken;
+                    _htmlLexicalAnalyzer.GetNextEqualSignToken();
+
+                    _htmlLexicalAnalyzer.GetNextAtomToken();
+
+                    var attributeValue = _htmlLexicalAnalyzer.NextToken;
+                    xmlElement.SetAttribute(attributeName, attributeValue);
+                }
+                _htmlLexicalAnalyzer.GetNextTagToken();
+            }
+        }
+
+        #endregion Private Methods
+
+        // ---------------------------------------------------------------------
+        //
+        // Private Fields
+        //
+        // ---------------------------------------------------------------------
+
+        #region Private Fields
+
+        internal const string XhtmlNamespace = "http://www.w3.org/1999/xhtml";
+
+        private readonly HtmlLexicalAnalyzer _htmlLexicalAnalyzer;
+
+        // document from which all elements are created
+        private readonly XmlDocument _document;
+
+        // stack for open elements
+        private readonly Stack<XmlElement> _openedElements;
+        private readonly Stack<XmlElement> _pendingInlineElements;
+
+        #endregion Private Fields
+    }
+}
diff --git a/MedLaunch/Classes/HtmlToXaml/HtmlSchema.cs b/MedLaunch/Classes/HtmlToXaml/HtmlSchema.cs
new file mode 100644
index 0000000..434ae9f
--- /dev/null
+++ b/MedLaunch/Classes/HtmlToXaml/HtmlSchema.cs
@@ -0,0 +1,730 @@
+using System.Collections;
+using System.Diagnostics;
+
+namespace MedLaunch.Classes.HtmlToXaml
+{
+    /// <summary>
+    ///     HtmlSchema class
+    ///     maintains static information about HTML structure
+    ///     can be used by HtmlParser to check conditions under which an element starts or ends, etc.
+    /// </summary>
+    internal class HtmlSchema
+    {
+        // ---------------------------------------------------------------------
+        //
+        // Constructors
+        //
+        // ---------------------------------------------------------------------
+
+        #region Constructors
+
+        /// <summary>
+        ///     static constructor, initializes the ArrayLists
+        ///     that hold the elements in various sub-components of the schema
+        ///     e.g _htmlEmptyElements, etc.
+        /// </summary>
+        static HtmlSchema()
+        {
+            // initializes the list of all html elements
+            InitializeInlineElements();
+
+            InitializeBlockElements();
+
+            InitializeOtherOpenableElements();
+
+            // initialize empty elements list
+            InitializeEmptyElements();
+
+            // initialize list of elements closing on the outer element end
+            InitializeElementsClosingOnParentElementEnd();
+
+            // initalize list of elements that close when a new element starts
+            InitializeElementsClosingOnNewElementStart();
+
+            // Initialize character entities
+            InitializeHtmlCharacterEntities();
+        }
+
+        #endregion Constructors;
+
+        // ---------------------------------------------------------------------
+        //
+        // Internal Methods
+        //
+        // ---------------------------------------------------------------------
+
+        #region Internal Methods
+
+        /// <summary>
+        ///     returns true when xmlElementName corresponds to empty element
+        /// </summary>
+        /// <param name="xmlElementName">
+        ///     string representing name to test
+        /// </param>
+        internal static bool IsEmptyElement(string xmlElementName) => _htmlEmptyElements.Contains(xmlElementName.ToLower());
+
+        /// <summary>
+        ///     returns true if xmlElementName represents a block formattinng element.
+        ///     It used in an algorithm of transferring inline elements over block elements
+        ///     in HtmlParser
+        /// </summary>
+        /// <param name="xmlElementName"></param>
+        /// <returns></returns>
+        internal static bool IsBlockElement(string xmlElementName) => _htmlBlockElements.Contains(xmlElementName);
+
+        /// <summary>
+        ///     returns true if the xmlElementName represents an inline formatting element
+        /// </summary>
+        /// <param name="xmlElementName"></param>
+        /// <returns></returns>
+        internal static bool IsInlineElement(string xmlElementName) => _htmlInlineElements.Contains(xmlElementName);
+
+        /// <summary>
+        ///     It is a list of known html elements which we
+        ///     want to allow to produce bt HTML parser,
+        ///     but don'tt want to act as inline, block or no-scope.
+        ///     Presence in this list will allow to open
+        ///     elements during html parsing, and adding the
+        ///     to a tree produced by html parser.
+        /// </summary>
+        internal static bool IsKnownOpenableElement(string xmlElementName) => _htmlOtherOpenableElements.Contains(xmlElementName);
+
+        /// <summary>
+        ///     returns true when xmlElementName closes when the outer element closes
+        ///     this is true of elements with optional start tags
+        /// </summary>
+        /// <param name="xmlElementName">
+        ///     string representing name to test
+        /// </param>
+        internal static bool ClosesOnParentElementEnd(string xmlElementName) => _htmlElementsClosingOnParentElementEnd.Contains(xmlElementName.ToLower());
+
+        /// <summary>
+        ///     returns true if the current element closes when the new element, whose name has just been read, starts
+        /// </summary>
+        /// <param name="currentElementName">
+        ///     string representing current element name
+        /// </param>
+        /// <param name="elementName"></param>
+        /// string representing name of the next element that will start
+        internal static bool ClosesOnNextElementStart(string currentElementName, string nextElementName)
+        {
+            Debug.Assert(currentElementName == currentElementName.ToLower());
+            switch (currentElementName)
+            {
+                case "colgroup":
+                    return _htmlElementsClosingColgroup.Contains(nextElementName) && IsBlockElement(nextElementName);
+                case "dd":
+                    return _htmlElementsClosingDd.Contains(nextElementName) && IsBlockElement(nextElementName);
+                case "dt":
+                    return _htmlElementsClosingDt.Contains(nextElementName) && IsBlockElement(nextElementName);
+                case "li":
+                    return _htmlElementsClosingLi.Contains(nextElementName);
+                case "p":
+                    return IsBlockElement(nextElementName);
+                case "tbody":
+                    return _htmlElementsClosingTbody.Contains(nextElementName);
+                case "tfoot":
+                    return _htmlElementsClosingTfoot.Contains(nextElementName);
+                case "thead":
+                    return _htmlElementsClosingThead.Contains(nextElementName);
+                case "tr":
+                    return _htmlElementsClosingTr.Contains(nextElementName);
+                case "td":
+                    return _htmlElementsClosingTd.Contains(nextElementName);
+                case "th":
+                    return _htmlElementsClosingTh.Contains(nextElementName);
+            }
+            return false;
+        }
+
+        /// <summary>
+        ///     returns true if the string passed as argument is an Html entity name
+        /// </summary>
+        /// <param name="entityName">
+        ///     string to be tested for Html entity name
+        /// </param>
+        internal static bool IsEntity(string entityName)
+        {
+            // we do not convert entity strings to lowercase because these names are case-sensitive
+            if (_htmlCharacterEntities.Contains(entityName))
+            {
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        ///     returns the character represented by the entity name string which is passed as an argument, if the string is an
+        ///     entity name
+        ///     as specified in _htmlCharacterEntities, returns the character value of 0 otherwise
+        /// </summary>
+        /// <param name="entityName">
+        ///     string representing entity name whose character value is desired
+        /// </param>
+        internal static char EntityCharacterValue(string entityName)
+        {
+            if (_htmlCharacterEntities.Contains(entityName))
+            {
+                return (char)_htmlCharacterEntities[entityName];
+            }
+            return (char)0;
+        }
+
+        #endregion Internal Methods
+
+        // ---------------------------------------------------------------------
+        //
+        //  Internal Properties
+        //
+        // ---------------------------------------------------------------------
+
+        #region Internal Properties
+
+        #endregion Internal Indexers
+
+        // ---------------------------------------------------------------------
+        //
+        // Private Methods
+        //
+        // ---------------------------------------------------------------------
+
+        #region Private Methods
+
+        private static void InitializeInlineElements()
+        {
+            _htmlInlineElements = new ArrayList
+            {
+                "a",
+                "abbr",
+                "acronym",
+                "address",
+                "b",
+                "bdo",
+                "big",
+                "button",
+                "code",
+                "del",
+                "dfn",
+                "em",
+                "font",
+                "i",
+                "ins",
+                "kbd",
+                "label",
+                "legend",
+                "q",
+                "s",
+                "samp",
+                "small",
+                "span",
+                "strike",
+                "strong",
+                "sub",
+                "sup",
+                "u",
+                "var"
+            };
+            // ???
+            // deleted text
+            // inserted text
+            // text to entered by a user
+            // ???
+            // short inline quotation
+            // strike-through text style
+            // Specifies a code sample
+            // indicates an instance of a program variable
+        }
+
+        private static void InitializeBlockElements()
+        {
+            _htmlBlockElements = new ArrayList
+            {
+                "blockquote",
+                "body",
+                "caption",
+                "center",
+                "cite",
+                "dd",
+                "dir",
+                "div",
+                "dl",
+                "dt",
+                "form",
+                "h1",
+                "h2",
+                "h3",
+                "h4",
+                "h5",
+                "h6",
+                "html",
+                "li",
+                "menu",
+                "ol",
+                "p",
+                "pre",
+                "table",
+                "tbody",
+                "td",
+                "textarea",
+                "tfoot",
+                "th",
+                "thead",
+                "tr",
+                "tt",
+                "ul"
+            };
+
+            //  treat as UL element
+            // Not a block according to XHTML spec
+            //  treat as UL element
+            // Renders text in a fixed-width font
+        }
+
+        /// <summary>
+        ///     initializes _htmlEmptyElements with empty elements in HTML 4 spec at
+        ///     http://www.w3.org/TR/REC-html40/index/elements.html
+        /// </summary>
+        private static void InitializeEmptyElements()
+        {
+            // Build a list of empty (no-scope) elements 
+            // (element not requiring closing tags, and not accepting any content)
+            _htmlEmptyElements = new ArrayList
+            {
+                "area",
+                "base",
+                "basefont",
+                "br",
+                "col",
+                "frame",
+                "hr",
+                "img",
+                "input",
+                "isindex",
+                "link",
+                "meta",
+                "param"
+            };
+        }
+
+        private static void InitializeOtherOpenableElements()
+        {
+            // It is a list of known html elements which we
+            // want to allow to produce bt HTML parser,
+            // but don'tt want to act as inline, block or no-scope.
+            // Presence in this list will allow to open
+            // elements during html parsing, and adding the
+            // to a tree produced by html parser.
+            _htmlOtherOpenableElements = new ArrayList
+            {
+                "applet",
+                "base",
+                "basefont",
+                "colgroup",
+                "fieldset",
+                "frameset",
+                "head",
+                "iframe",
+                "map",
+                "noframes",
+                "noscript",
+                "object",
+                "optgroup",
+                "option",
+                "script",
+                "select",
+                "style",
+                "title"
+            };
+            //_htmlOtherOpenableElements.Add("form"); --> treated as block
+        }
+
+        /// <summary>
+        ///     initializes _htmlElementsClosingOnParentElementEnd with the list of HTML 4 elements for which closing tags are
+        ///     optional
+        ///     we assume that for any element for which closing tags are optional, the element closes when it's outer element
+        ///     (in which it is nested) does
+        /// </summary>
+        private static void InitializeElementsClosingOnParentElementEnd()
+        {
+            _htmlElementsClosingOnParentElementEnd = new ArrayList
+            {
+                "body",
+                "colgroup",
+                "dd",
+                "dt",
+                "head",
+                "html",
+                "li",
+                "p",
+                "tbody",
+                "td",
+                "tfoot",
+                "thead",
+                "th",
+                "tr"
+            };
+        }
+
+        private static void InitializeElementsClosingOnNewElementStart()
+        {
+            _htmlElementsClosingColgroup = new ArrayList { "colgroup", "tr", "thead", "tfoot", "tbody" };
+
+            _htmlElementsClosingDd = new ArrayList { "dd", "dt" };
+            // TODO: dd may end in other cases as well - if a new "p" starts, etc.
+            // TODO: these are the basic "legal" cases but there may be more recovery
+
+            _htmlElementsClosingDt = new ArrayList();
+            _htmlElementsClosingDd.Add("dd");
+            _htmlElementsClosingDd.Add("dt");
+            // TODO: dd may end in other cases as well - if a new "p" starts, etc.
+            // TODO: these are the basic "legal" cases but there may be more recovery
+
+            _htmlElementsClosingLi = new ArrayList { "li" };
+            // TODO: more complex recovery
+
+            _htmlElementsClosingTbody = new ArrayList { "tbody", "thead", "tfoot" };
+            // TODO: more complex recovery
+
+            _htmlElementsClosingTr = new ArrayList { "thead", "tfoot", "tbody", "tr" };
+            // NOTE: tr should not really close on a new thead
+            // because if there are rows before a thead, it is assumed to be in tbody, whose start tag is optional
+            // and thead can't come after tbody
+            // however, if we do encounter this, it's probably best to end the row and ignore the thead or treat
+            // it as part of the table
+            // TODO: more complex recovery
+
+            _htmlElementsClosingTd = new ArrayList { "td", "th", "tr", "tbody", "tfoot", "thead" };
+            // TODO: more complex recovery
+
+            _htmlElementsClosingTh = new ArrayList { "td", "th", "tr", "tbody", "tfoot", "thead" };
+            // TODO: more complex recovery
+
+            _htmlElementsClosingThead = new ArrayList { "tbody", "tfoot" };
+            // TODO: more complex recovery
+
+            _htmlElementsClosingTfoot = new ArrayList { "tbody", "thead" };
+            // although thead comes before tfoot, we add it because if it is found the tfoot should close
+            // and some recovery processing be done on the thead
+            // TODO: more complex recovery
+        }
+
+        /// <summary>
+        ///     initializes _htmlCharacterEntities hashtable with the character corresponding to entity names
+        /// </summary>
+        private static void InitializeHtmlCharacterEntities()
+        {
+            _htmlCharacterEntities = new Hashtable
+            {
+                ["Aacute"] = (char)193,
+                ["aacute"] = (char)225,
+                ["Acirc"] = (char)194,
+                ["acirc"] = (char)226,
+                ["acute"] = (char)180,
+                ["AElig"] = (char)198,
+                ["aelig"] = (char)230,
+                ["Agrave"] = (char)192,
+                ["agrave"] = (char)224,
+                ["alefsym"] = (char)8501,
+                ["Alpha"] = (char)913,
+                ["alpha"] = (char)945,
+                ["amp"] = (char)38,
+                ["and"] = (char)8743,
+                ["ang"] = (char)8736,
+                ["Aring"] = (char)197,
+                ["aring"] = (char)229,
+                ["asymp"] = (char)8776,
+                ["Atilde"] = (char)195,
+                ["atilde"] = (char)227,
+                ["Auml"] = (char)196,
+                ["auml"] = (char)228,
+                ["bdquo"] = (char)8222,
+                ["Beta"] = (char)914,
+                ["beta"] = (char)946,
+                ["brvbar"] = (char)166,
+                ["bull"] = (char)8226,
+                ["cap"] = (char)8745,
+                ["Ccedil"] = (char)199,
+                ["ccedil"] = (char)231,
+                ["cent"] = (char)162,
+                ["Chi"] = (char)935,
+                ["chi"] = (char)967,
+                ["circ"] = (char)710,
+                ["clubs"] = (char)9827,
+                ["cong"] = (char)8773,
+                ["copy"] = (char)169,
+                ["crarr"] = (char)8629,
+                ["cup"] = (char)8746,
+                ["curren"] = (char)164,
+                ["dagger"] = (char)8224,
+                ["Dagger"] = (char)8225,
+                ["darr"] = (char)8595,
+                ["dArr"] = (char)8659,
+                ["deg"] = (char)176,
+                ["Delta"] = (char)916,
+                ["delta"] = (char)948,
+                ["diams"] = (char)9830,
+                ["divide"] = (char)247,
+                ["Eacute"] = (char)201,
+                ["eacute"] = (char)233,
+                ["Ecirc"] = (char)202,
+                ["ecirc"] = (char)234,
+                ["Egrave"] = (char)200,
+                ["egrave"] = (char)232,
+                ["empty"] = (char)8709,
+                ["emsp"] = (char)8195,
+                ["ensp"] = (char)8194,
+                ["Epsilon"] = (char)917,
+                ["epsilon"] = (char)949,
+                ["equiv"] = (char)8801,
+                ["Eta"] = (char)919,
+                ["eta"] = (char)951,
+                ["ETH"] = (char)208,
+                ["eth"] = (char)240,
+                ["Euml"] = (char)203,
+                ["euml"] = (char)235,
+                ["euro"] = (char)8364,
+                ["exist"] = (char)8707,
+                ["fnof"] = (char)402,
+                ["forall"] = (char)8704,
+                ["frac12"] = (char)189,
+                ["frac14"] = (char)188,
+                ["frac34"] = (char)190,
+                ["frasl"] = (char)8260,
+                ["Gamma"] = (char)915,
+                ["gamma"] = (char)947,
+                ["ge"] = (char)8805,
+                ["gt"] = (char)62,
+                ["harr"] = (char)8596,
+                ["hArr"] = (char)8660,
+                ["hearts"] = (char)9829,
+                ["hellip"] = (char)8230,
+                ["Iacute"] = (char)205,
+                ["iacute"] = (char)237,
+                ["Icirc"] = (char)206,
+                ["icirc"] = (char)238,
+                ["iexcl"] = (char)161,
+                ["Igrave"] = (char)204,
+                ["igrave"] = (char)236,
+                ["image"] = (char)8465,
+                ["infin"] = (char)8734,
+                ["int"] = (char)8747,
+                ["Iota"] = (char)921,
+                ["iota"] = (char)953,
+                ["iquest"] = (char)191,
+                ["isin"] = (char)8712,
+                ["Iuml"] = (char)207,
+                ["iuml"] = (char)239,
+                ["Kappa"] = (char)922,
+                ["kappa"] = (char)954,
+                ["Lambda"] = (char)923,
+                ["lambda"] = (char)955,
+                ["lang"] = (char)9001,
+                ["laquo"] = (char)171,
+                ["larr"] = (char)8592,
+                ["lArr"] = (char)8656,
+                ["lceil"] = (char)8968,
+                ["ldquo"] = (char)8220,
+                ["le"] = (char)8804,
+                ["lfloor"] = (char)8970,
+                ["lowast"] = (char)8727,
+                ["loz"] = (char)9674,
+                ["lrm"] = (char)8206,
+                ["lsaquo"] = (char)8249,
+                ["lsquo"] = (char)8216,
+                ["lt"] = (char)60,
+                ["macr"] = (char)175,
+                ["mdash"] = (char)8212,
+                ["micro"] = (char)181,
+                ["middot"] = (char)183,
+                ["minus"] = (char)8722,
+                ["Mu"] = (char)924,
+                ["mu"] = (char)956,
+                ["nabla"] = (char)8711,
+                ["nbsp"] = (char)160,
+                ["ndash"] = (char)8211,
+                ["ne"] = (char)8800,
+                ["ni"] = (char)8715,
+                ["not"] = (char)172,
+                ["notin"] = (char)8713,
+                ["nsub"] = (char)8836,
+                ["Ntilde"] = (char)209,
+                ["ntilde"] = (char)241,
+                ["Nu"] = (char)925,
+                ["nu"] = (char)957,
+                ["Oacute"] = (char)211,
+                ["ocirc"] = (char)244,
+                ["OElig"] = (char)338,
+                ["oelig"] = (char)339,
+                ["Ograve"] = (char)210,
+                ["ograve"] = (char)242,
+                ["oline"] = (char)8254,
+                ["Omega"] = (char)937,
+                ["omega"] = (char)969,
+                ["Omicron"] = (char)927,
+                ["omicron"] = (char)959,
+                ["oplus"] = (char)8853,
+                ["or"] = (char)8744,
+                ["ordf"] = (char)170,
+                ["ordm"] = (char)186,
+                ["Oslash"] = (char)216,
+                ["oslash"] = (char)248,
+                ["Otilde"] = (char)213,
+                ["otilde"] = (char)245,
+                ["otimes"] = (char)8855,
+                ["Ouml"] = (char)214,
+                ["ouml"] = (char)246,
+                ["para"] = (char)182,
+                ["part"] = (char)8706,
+                ["permil"] = (char)8240,
+                ["perp"] = (char)8869,
+                ["Phi"] = (char)934,
+                ["phi"] = (char)966,
+                ["pi"] = (char)960,
+                ["piv"] = (char)982,
+                ["plusmn"] = (char)177,
+                ["pound"] = (char)163,
+                ["prime"] = (char)8242,
+                ["Prime"] = (char)8243,
+                ["prod"] = (char)8719,
+                ["prop"] = (char)8733,
+                ["Psi"] = (char)936,
+                ["psi"] = (char)968,
+                ["quot"] = (char)34,
+                ["radic"] = (char)8730,
+                ["rang"] = (char)9002,
+                ["raquo"] = (char)187,
+                ["rarr"] = (char)8594,
+                ["rArr"] = (char)8658,
+                ["rceil"] = (char)8969,
+                ["rdquo"] = (char)8221,
+                ["real"] = (char)8476,
+                ["reg"] = (char)174,
+                ["rfloor"] = (char)8971,
+                ["Rho"] = (char)929,
+                ["rho"] = (char)961,
+                ["rlm"] = (char)8207,
+                ["rsaquo"] = (char)8250,
+                ["rsquo"] = (char)8217,
+                ["sbquo"] = (char)8218,
+                ["Scaron"] = (char)352,
+                ["scaron"] = (char)353,
+                ["sdot"] = (char)8901,
+                ["sect"] = (char)167,
+                ["shy"] = (char)173,
+                ["Sigma"] = (char)931,
+                ["sigma"] = (char)963,
+                ["sigmaf"] = (char)962,
+                ["sim"] = (char)8764,
+                ["spades"] = (char)9824,
+                ["sub"] = (char)8834,
+                ["sube"] = (char)8838,
+                ["sum"] = (char)8721,
+                ["sup"] = (char)8835,
+                ["sup1"] = (char)185,
+                ["sup2"] = (char)178,
+                ["sup3"] = (char)179,
+                ["supe"] = (char)8839,
+                ["szlig"] = (char)223,
+                ["Tau"] = (char)932,
+                ["tau"] = (char)964,
+                ["there4"] = (char)8756,
+                ["Theta"] = (char)920,
+                ["theta"] = (char)952,
+                ["thetasym"] = (char)977,
+                ["thinsp"] = (char)8201,
+                ["THORN"] = (char)222,
+                ["thorn"] = (char)254,
+                ["tilde"] = (char)732,
+                ["times"] = (char)215,
+                ["trade"] = (char)8482,
+                ["Uacute"] = (char)218,
+                ["uacute"] = (char)250,
+                ["uarr"] = (char)8593,
+                ["uArr"] = (char)8657,
+                ["Ucirc"] = (char)219,
+                ["ucirc"] = (char)251,
+                ["Ugrave"] = (char)217,
+                ["ugrave"] = (char)249,
+                ["uml"] = (char)168,
+                ["upsih"] = (char)978,
+                ["Upsilon"] = (char)933,
+                ["upsilon"] = (char)965,
+                ["Uuml"] = (char)220,
+                ["uuml"] = (char)252,
+                ["weierp"] = (char)8472,
+                ["Xi"] = (char)926,
+                ["xi"] = (char)958,
+                ["Yacute"] = (char)221,
+                ["yacute"] = (char)253,
+                ["yen"] = (char)165,
+                ["Yuml"] = (char)376,
+                ["yuml"] = (char)255,
+                ["Zeta"] = (char)918,
+                ["zeta"] = (char)950,
+                ["zwj"] = (char)8205,
+                ["zwnj"] = (char)8204
+            };
+        }
+
+        #endregion Private Methods
+
+        // ---------------------------------------------------------------------
+        //
+        // Private Fields
+        //
+        // ---------------------------------------------------------------------
+
+        #region Private Fields
+
+        // html element names
+        // this is an array list now, but we may want to make it a hashtable later for better performance
+        private static ArrayList _htmlInlineElements;
+
+        private static ArrayList _htmlBlockElements;
+
+        private static ArrayList _htmlOtherOpenableElements;
+
+        // list of html empty element names
+        private static ArrayList _htmlEmptyElements;
+
+        // names of html elements for which closing tags are optional, and close when the outer nested element closes
+        private static ArrayList _htmlElementsClosingOnParentElementEnd;
+
+        // names of elements that close certain optional closing tag elements when they start
+
+        // names of elements closing the colgroup element
+        private static ArrayList _htmlElementsClosingColgroup;
+
+        // names of elements closing the dd element
+        private static ArrayList _htmlElementsClosingDd;
+
+        // names of elements closing the dt element
+        private static ArrayList _htmlElementsClosingDt;
+
+        // names of elements closing the li element
+        private static ArrayList _htmlElementsClosingLi;
+
+        // names of elements closing the tbody element
+        private static ArrayList _htmlElementsClosingTbody;
+
+        // names of elements closing the td element
+        private static ArrayList _htmlElementsClosingTd;
+
+        // names of elements closing the tfoot element
+        private static ArrayList _htmlElementsClosingTfoot;
+
+        // names of elements closing the thead element
+        private static ArrayList _htmlElementsClosingThead;
+
+        // names of elements closing the th element
+        private static ArrayList _htmlElementsClosingTh;
+
+        // names of elements closing the tr element
+        private static ArrayList _htmlElementsClosingTr;
+
+        // html character entities hashtable
+        private static Hashtable _htmlCharacterEntities;
+
+        #endregion Private Fields
+    }
+}
diff --git a/MedLaunch/Classes/HtmlToXaml/HtmlToXamlConverter.cs b/MedLaunch/Classes/HtmlToXaml/HtmlToXamlConverter.cs
new file mode 100644
index 0000000..715b969
--- /dev/null
+++ b/MedLaunch/Classes/HtmlToXaml/HtmlToXamlConverter.cs
@@ -0,0 +1,2753 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Documents;
+using System.Xml;
+
+
+namespace MedLaunch.Classes.HtmlToXaml
+{
+    // DependencyProperty
+
+    // TextElement
+
+    /// <summary>
+    ///     HtmlToXamlConverter is a static class that takes an HTML string
+    ///     and converts it into XAML
+    /// </summary>
+    public static class HtmlToXamlConverter
+    {
+        // ----------------------------------------------------------------
+        //
+        // Internal Constants
+        //
+        // ----------------------------------------------------------------
+
+        // The constants reprtesent all Xaml names used in a conversion
+        public const string XamlFlowDocument = "FlowDocument";
+        public const string XamlRun = "Run";
+        public const string XamlSpan = "Span";
+        public const string XamlHyperlink = "Hyperlink";
+        public const string XamlHyperlinkNavigateUri = "NavigateUri";
+        public const string XamlHyperlinkTargetName = "TargetName";
+        public const string XamlSection = "Section";
+        public const string XamlList = "List";
+        public const string XamlListMarkerStyle = "MarkerStyle";
+        public const string XamlListMarkerStyleNone = "None";
+        public const string XamlListMarkerStyleDecimal = "Decimal";
+        public const string XamlListMarkerStyleDisc = "Disc";
+        public const string XamlListMarkerStyleCircle = "Circle";
+        public const string XamlListMarkerStyleSquare = "Square";
+        public const string XamlListMarkerStyleBox = "Box";
+        public const string XamlListMarkerStyleLowerLatin = "LowerLatin";
+        public const string XamlListMarkerStyleUpperLatin = "UpperLatin";
+        public const string XamlListMarkerStyleLowerRoman = "LowerRoman";
+        public const string XamlListMarkerStyleUpperRoman = "UpperRoman";
+        public const string XamlListItem = "ListItem";
+        public const string XamlLineBreak = "LineBreak";
+        public const string XamlParagraph = "Paragraph";
+        public const string XamlMargin = "Margin";
+        public const string XamlPadding = "Padding";
+        public const string XamlBorderBrush = "BorderBrush";
+        public const string XamlBorderThickness = "BorderThickness";
+        public const string XamlTable = "Table";
+        public const string XamlTableColumn = "TableColumn";
+        public const string XamlTableRowGroup = "TableRowGroup";
+        public const string XamlTableRow = "TableRow";
+        public const string XamlTableCell = "TableCell";
+        public const string XamlTableCellBorderThickness = "BorderThickness";
+        public const string XamlTableCellBorderBrush = "BorderBrush";
+        public const string XamlTableCellColumnSpan = "ColumnSpan";
+        public const string XamlTableCellRowSpan = "RowSpan";
+        public const string XamlWidth = "Width";
+        public const string XamlBrushesBlack = "Black";
+        public const string XamlFontFamily = "FontFamily";
+        public const string XamlFontSize = "FontSize";
+        public const string XamlFontSizeXxLarge = "22pt"; // "XXLarge";
+        public const string XamlFontSizeXLarge = "20pt"; // "XLarge";
+        public const string XamlFontSizeLarge = "18pt"; // "Large";
+        public const string XamlFontSizeMedium = "16pt"; // "Medium";
+        public const string XamlFontSizeSmall = "12pt"; // "Small";
+        public const string XamlFontSizeXSmall = "10pt"; // "XSmall";
+        public const string XamlFontSizeXxSmall = "8pt"; // "XXSmall";
+        public const string XamlFontWeight = "FontWeight";
+        public const string XamlFontWeightBold = "Bold";
+        public const string XamlFontStyle = "FontStyle";
+        public const string XamlForeground = "Foreground";
+        public const string XamlBackground = "Background";
+        public const string XamlTextDecorations = "TextDecorations";
+        public const string XamlTextDecorationsUnderline = "Underline";
+        public const string XamlTextIndent = "TextIndent";
+        public const string XamlTextAlignment = "TextAlignment";
+        // ---------------------------------------------------------------------
+        //
+        // Private Fields
+        //
+        // ---------------------------------------------------------------------
+
+        #region Private Fields
+
+        private static readonly string XamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
+
+        #endregion Private Fields
+
+        // ---------------------------------------------------------------------
+        //
+        // Internal Methods
+        //
+        // ---------------------------------------------------------------------
+
+        #region Internal Methods
+
+        /// <summary>
+        ///     Converts an html string into xaml string.
+        /// </summary>
+        /// <param name="htmlString">
+        ///     Input html which may be badly formated xml.
+        /// </param>
+        /// <param name="asFlowDocument">
+        ///     true indicates that we need a FlowDocument as a root element;
+        ///     false means that Section or Span elements will be used
+        ///     dependeing on StartFragment/EndFragment comments locations.
+        /// </param>
+        /// <returns>
+        ///     Well-formed xml representing XAML equivalent for the input html string.
+        /// </returns>
+        public static string ConvertHtmlToXaml(string htmlString, bool asFlowDocument)
+        {
+            // Create well-formed Xml from Html string
+            var htmlElement = HtmlParser.ParseHtml(htmlString);
+
+            // Decide what name to use as a root
+            var rootElementName = asFlowDocument ? XamlFlowDocument : XamlSection;
+
+            // Create an XmlDocument for generated xaml
+            var xamlTree = new XmlDocument();
+            var xamlFlowDocumentElement = xamlTree.CreateElement(null, rootElementName, XamlNamespace);
+
+            // Extract style definitions from all STYLE elements in the document
+            var stylesheet = new CssStylesheet(htmlElement);
+
+            // Source context is a stack of all elements - ancestors of a parentElement
+            var sourceContext = new List<XmlElement>(10);
+
+            // Clear fragment parent
+            _inlineFragmentParentElement = null;
+
+            // convert root html element
+            AddBlock(xamlFlowDocumentElement, htmlElement, new Hashtable(), stylesheet, sourceContext);
+
+            // In case if the selected fragment is inline, extract it into a separate Span wrapper
+            if (!asFlowDocument)
+            {
+                xamlFlowDocumentElement = ExtractInlineFragment(xamlFlowDocumentElement);
+            }
+
+            // Return a string representing resulting Xaml
+            xamlFlowDocumentElement.SetAttribute("xml:space", "preserve");
+            var xaml = xamlFlowDocumentElement.OuterXml;
+
+            return xaml;
+        }
+
+        /// <summary>
+        ///     Returns a value for an attribute by its name (ignoring casing)
+        /// </summary>
+        /// <param name="element">
+        ///     XmlElement in which we are trying to find the specified attribute
+        /// </param>
+        /// <param name="attributeName">
+        ///     String representing the attribute name to be searched for
+        /// </param>
+        /// <returns></returns>
+        public static string GetAttribute(XmlElement element, string attributeName)
+        {
+            attributeName = attributeName.ToLower();
+
+            for (var i = 0; i < element.Attributes.Count; i++)
+            {
+                if (element.Attributes[i].Name.ToLower() == attributeName)
+                {
+                    return element.Attributes[i].Value;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        ///     Returns string extracted from quotation marks
+        /// </summary>
+        /// <param name="value">
+        ///     String representing value enclosed in quotation marks
+        /// </param>
+        internal static string UnQuote(string value)
+        {
+            if (value.StartsWith("\"") && value.EndsWith("\"") || value.StartsWith("'") && value.EndsWith("'"))
+            {
+                value = value.Substring(1, value.Length - 2).Trim();
+            }
+            return value;
+        }
+
+        #endregion Internal Methods
+
+        // ---------------------------------------------------------------------
+        //
+        // Private Methods
+        //
+        // ---------------------------------------------------------------------
+
+        #region Private Methods
+
+        /// <summary>
+        ///     Analyzes the given htmlElement expecting it to be converted
+        ///     into some of xaml Block elements and adds the converted block
+        ///     to the children collection of xamlParentElement.
+        ///     Analyzes the given XmlElement htmlElement, recognizes it as some HTML element
+        ///     and adds it as a child to a xamlParentElement.
+        ///     In some cases several following siblings of the given htmlElement
+        ///     will be consumed too (e.g. LIs encountered without wrapping UL/OL,
+        ///     which must be collected together and wrapped into one implicit List element).
+        /// </summary>
+        /// <param name="xamlParentElement">
+        ///     Parent xaml element, to which new converted element will be added
+        /// </param>
+        /// <param name="htmlElement">
+        ///     Source html element subject to convert to xaml.
+        /// </param>
+        /// <param name="inheritedProperties">
+        ///     Properties inherited from an outer context.
+        /// </param>
+        /// <param name="stylesheet"></param>
+        /// <param name="sourceContext"></param>
+        /// <returns>
+        ///     Last processed html node. Normally it should be the same htmlElement
+        ///     as was passed as a paramater, but in some irregular cases
+        ///     it could one of its following siblings.
+        ///     The caller must use this node to get to next sibling from it.
+        /// </returns>
+        private static XmlNode AddBlock(XmlElement xamlParentElement, XmlNode htmlNode, Hashtable inheritedProperties,
+            CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            if (htmlNode is XmlComment)
+            {
+                DefineInlineFragmentParent((XmlComment)htmlNode, /*xamlParentElement:*/null);
+            }
+            else if (htmlNode is XmlText)
+            {
+                htmlNode = AddImplicitParagraph(xamlParentElement, htmlNode, inheritedProperties, stylesheet,
+                    sourceContext);
+            }
+            else if (htmlNode is XmlElement)
+            {
+                // Identify element name
+                var htmlElement = (XmlElement)htmlNode;
+
+                var htmlElementName = htmlElement.LocalName; // Keep the name case-sensitive to check xml names
+                var htmlElementNamespace = htmlElement.NamespaceURI;
+
+                if (htmlElementNamespace != HtmlParser.XhtmlNamespace)
+                {
+                    // Non-html element. skip it
+                    // Isn't it too agressive? What if this is just an error in html tag name?
+                    // TODO: Consider skipping just a wparrer in recursing into the element tree,
+                    // which may produce some garbage though coming from xml fragments.
+                    return htmlElement;
+                }
+
+                // Put source element to the stack
+                sourceContext.Add(htmlElement);
+
+                // Convert the name to lowercase, because html elements are case-insensitive
+                htmlElementName = htmlElementName.ToLower();
+
+                // Switch to an appropriate kind of processing depending on html element name
+                switch (htmlElementName)
+                {
+                    // Sections:
+                    case "html":
+                    case "body":
+                    case "div":
+                    case "form": // not a block according to xhtml spec
+                    case "pre": // Renders text in a fixed-width font
+                    case "blockquote":
+                    case "caption":
+                    case "center":
+                    case "cite":
+                        AddSection(xamlParentElement, htmlElement, inheritedProperties, stylesheet, sourceContext);
+                        break;
+
+                    // Paragraphs:
+                    case "p":
+                    case "h1":
+                    case "h2":
+                    case "h3":
+                    case "h4":
+                    case "h5":
+                    case "h6":
+                    case "nsrtitle":
+                    case "textarea":
+                    case "dd": // ???
+                    case "dl": // ???
+                    case "dt": // ???
+                    case "tt": // ???
+                        AddParagraph(xamlParentElement, htmlElement, inheritedProperties, stylesheet, sourceContext);
+                        break;
+
+                    case "ol":
+                    case "ul":
+                    case "dir": //  treat as UL element
+                    case "menu": //  treat as UL element
+                        // List element conversion
+                        AddList(xamlParentElement, htmlElement, inheritedProperties, stylesheet, sourceContext);
+                        break;
+                    case "li":
+                        // LI outside of OL/UL
+                        // Collect all sibling LIs, wrap them into a List and then proceed with the element following the last of LIs
+                        htmlNode = AddOrphanListItems(xamlParentElement, htmlElement, inheritedProperties, stylesheet,
+                            sourceContext);
+                        break;
+
+                    case "img":
+                        // TODO: Add image processing
+                        AddImage(xamlParentElement, htmlElement, inheritedProperties, stylesheet, sourceContext);
+                        break;
+
+                    case "table":
+                        // hand off to table parsing function which will perform special table syntax checks
+                        AddTable(xamlParentElement, htmlElement, inheritedProperties, stylesheet, sourceContext);
+                        break;
+
+                    case "tbody":
+                    case "tfoot":
+                    case "thead":
+                    case "tr":
+                    case "td":
+                    case "th":
+                        // Table stuff without table wrapper
+                        // TODO: add special-case processing here for elements that should be within tables when the
+                        // parent element is NOT a table. If the parent element is a table they can be processed normally.
+                        // we need to compare against the parent element here, we can't just break on a switch
+                        goto default; // Thus we will skip this element as unknown, but still recurse into it.
+
+                    case "style": // We already pre-processed all style elements. Ignore it now
+                    case "meta":
+                    case "head":
+                    case "title":
+                    case "script":
+                        // Ignore these elements
+                        break;
+
+                    default:
+                        // Wrap a sequence of inlines into an implicit paragraph
+                        htmlNode = AddImplicitParagraph(xamlParentElement, htmlElement, inheritedProperties, stylesheet,
+                            sourceContext);
+                        break;
+                }
+
+                // Remove the element from the stack
+                Debug.Assert(sourceContext.Count > 0 && sourceContext[sourceContext.Count - 1] == htmlElement);
+                sourceContext.RemoveAt(sourceContext.Count - 1);
+            }
+
+            // Return last processed node
+            return htmlNode;
+        }
+
+        // .............................................................
+        //
+        // Line Breaks
+        //
+        // .............................................................
+
+        private static void AddBreak(XmlElement xamlParentElement, string htmlElementName)
+        {
+            // Create new xaml element corresponding to this html element
+            var xamlLineBreak = xamlParentElement.OwnerDocument.CreateElement( /*prefix:*/
+                null, /*localName:*/XamlLineBreak, XamlNamespace);
+            xamlParentElement.AppendChild(xamlLineBreak);
+            if (htmlElementName == "hr")
+            {
+                var xamlHorizontalLine = xamlParentElement.OwnerDocument.CreateTextNode("----------------------");
+                xamlParentElement.AppendChild(xamlHorizontalLine);
+                xamlLineBreak = xamlParentElement.OwnerDocument.CreateElement( /*prefix:*/
+                    null, /*localName:*/XamlLineBreak, XamlNamespace);
+                xamlParentElement.AppendChild(xamlLineBreak);
+            }
+        }
+
+        // .............................................................
+        //
+        // Text Flow Elements
+        //
+        // .............................................................
+
+        /// <summary>
+        ///     Generates Section or Paragraph element from DIV depending whether it contains any block elements or not
+        /// </summary>
+        /// <param name="xamlParentElement">
+        ///     XmlElement representing Xaml parent to which the converted element should be added
+        /// </param>
+        /// <param name="htmlElement">
+        ///     XmlElement representing Html element to be converted
+        /// </param>
+        /// <param name="inheritedProperties">
+        ///     properties inherited from parent context
+        /// </param>
+        /// <param name="stylesheet"></param>
+        /// <param name="sourceContext"></param>
+        /// true indicates that a content added by this call contains at least one block element
+        /// </param>
+        private static void AddSection(XmlElement xamlParentElement, XmlElement htmlElement,
+            Hashtable inheritedProperties,
+            CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            // Analyze the content of htmlElement to decide what xaml element to choose - Section or Paragraph.
+            // If this Div has at least one block child then we need to use Section, otherwise use Paragraph
+            var htmlElementContainsBlocks = false;
+            for (var htmlChildNode = htmlElement.FirstChild;
+                htmlChildNode != null;
+                htmlChildNode = htmlChildNode.NextSibling)
+            {
+                if (htmlChildNode is XmlElement)
+                {
+                    var htmlChildName = ((XmlElement)htmlChildNode).LocalName.ToLower();
+                    if (HtmlSchema.IsBlockElement(htmlChildName))
+                    {
+                        htmlElementContainsBlocks = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!htmlElementContainsBlocks)
+            {
+                // The Div does not contain any block elements, so we can treat it as a Paragraph
+                AddParagraph(xamlParentElement, htmlElement, inheritedProperties, stylesheet, sourceContext);
+            }
+            else
+            {
+                // The Div has some nested blocks, so we treat it as a Section
+
+                // Create currentProperties as a compilation of local and inheritedProperties, set localProperties
+                Hashtable localProperties;
+                var currentProperties = GetElementProperties(htmlElement, inheritedProperties, out localProperties,
+                    stylesheet,
+                    sourceContext);
+
+                // Create a XAML element corresponding to this html element
+                var xamlElement = xamlParentElement.OwnerDocument.CreateElement( /*prefix:*/
+                    null, /*localName:*/XamlSection, XamlNamespace);
+                ApplyLocalProperties(xamlElement, localProperties, /*isBlock:*/true);
+
+                // Decide whether we can unwrap this element as not having any formatting significance.
+                if (!xamlElement.HasAttributes)
+                {
+                    // This elements is a group of block elements whitout any additional formatting.
+                    // We can add blocks directly to xamlParentElement and avoid
+                    // creating unnecessary Sections nesting.
+                    xamlElement = xamlParentElement;
+                }
+
+                // Recurse into element subtree
+                for (var htmlChildNode = htmlElement.FirstChild;
+                    htmlChildNode != null;
+                    htmlChildNode = htmlChildNode?.NextSibling)
+                {
+                    htmlChildNode = AddBlock(xamlElement, htmlChildNode, currentProperties, stylesheet, sourceContext);
+                }
+
+                // Add the new element to the parent.
+                if (xamlElement != xamlParentElement)
+                {
+                    xamlParentElement.AppendChild(xamlElement);
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Generates Paragraph element from P, H1-H7, Center etc.
+        /// </summary>
+        /// <param name="xamlParentElement">
+        ///     XmlElement representing Xaml parent to which the converted element should be added
+        /// </param>
+        /// <param name="htmlElement">
+        ///     XmlElement representing Html element to be converted
+        /// </param>
+        /// <param name="inheritedProperties">
+        ///     properties inherited from parent context
+        /// </param>
+        /// <param name="stylesheet"></param>
+        /// <param name="sourceContext"></param>
+        /// true indicates that a content added by this call contains at least one block element
+        /// </param>
+        private static void AddParagraph(XmlElement xamlParentElement, XmlElement htmlElement,
+            Hashtable inheritedProperties,
+            CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            // Create currentProperties as a compilation of local and inheritedProperties, set localProperties
+            Hashtable localProperties;
+            var currentProperties = GetElementProperties(htmlElement, inheritedProperties, out localProperties,
+                stylesheet,
+                sourceContext);
+
+            // Create a XAML element corresponding to this html element
+            var xamlElement = xamlParentElement.OwnerDocument.CreateElement( /*prefix:*/
+                null, /*localName:*/XamlParagraph, XamlNamespace);
+            ApplyLocalProperties(xamlElement, localProperties, /*isBlock:*/true);
+
+            // Recurse into element subtree
+            for (var htmlChildNode = htmlElement.FirstChild;
+                htmlChildNode != null;
+                htmlChildNode = htmlChildNode.NextSibling)
+            {
+                AddInline(xamlElement, htmlChildNode, currentProperties, stylesheet, sourceContext);
+            }
+
+            // Add the new element to the parent.
+            xamlParentElement.AppendChild(xamlElement);
+        }
+
+        /// <summary>
+        ///     Creates a Paragraph element and adds all nodes starting from htmlNode
+        ///     converted to appropriate Inlines.
+        /// </summary>
+        /// <param name="xamlParentElement">
+        ///     XmlElement representing Xaml parent to which the converted element should be added
+        /// </param>
+        /// <param name="htmlNode">
+        ///     XmlNode starting a collection of implicitly wrapped inlines.
+        /// </param>
+        /// <param name="inheritedProperties">
+        ///     properties inherited from parent context
+        /// </param>
+        /// <param name="stylesheet"></param>
+        /// <param name="sourceContext"></param>
+        /// true indicates that a content added by this call contains at least one block element
+        /// </param>
+        /// <returns>
+        ///     The last htmlNode added to the implicit paragraph
+        /// </returns>
+        private static XmlNode AddImplicitParagraph(XmlElement xamlParentElement, XmlNode htmlNode,
+            Hashtable inheritedProperties, CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            // Collect all non-block elements and wrap them into implicit Paragraph
+            var xamlParagraph = xamlParentElement.OwnerDocument.CreateElement( /*prefix:*/
+                null, /*localName:*/XamlParagraph, XamlNamespace);
+            XmlNode lastNodeProcessed = null;
+            while (htmlNode != null)
+            {
+                if (htmlNode is XmlComment)
+                {
+                    DefineInlineFragmentParent((XmlComment)htmlNode, /*xamlParentElement:*/null);
+                }
+                else if (htmlNode is XmlText)
+                {
+                    if (htmlNode.Value.Trim().Length > 0)
+                    {
+                        AddTextRun(xamlParagraph, htmlNode.Value);
+                    }
+                }
+                else if (htmlNode is XmlElement)
+                {
+                    var htmlChildName = ((XmlElement)htmlNode).LocalName.ToLower();
+                    if (HtmlSchema.IsBlockElement(htmlChildName))
+                    {
+                        // The sequence of non-blocked inlines ended. Stop implicit loop here.
+                        break;
+                    }
+                    AddInline(xamlParagraph, (XmlElement)htmlNode, inheritedProperties, stylesheet, sourceContext);
+                }
+
+                // Store last processed node to return it at the end
+                lastNodeProcessed = htmlNode;
+                htmlNode = htmlNode.NextSibling;
+            }
+
+            // Add the Paragraph to the parent
+            // If only whitespaces and commens have been encountered,
+            // then we have nothing to add in implicit paragraph; forget it.
+            if (xamlParagraph.FirstChild != null)
+            {
+                xamlParentElement.AppendChild(xamlParagraph);
+            }
+
+            // Need to return last processed node
+            return lastNodeProcessed;
+        }
+
+        // .............................................................
+        //
+        // Inline Elements
+        //
+        // .............................................................
+
+        private static void AddInline(XmlElement xamlParentElement, XmlNode htmlNode, Hashtable inheritedProperties,
+            CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            if (htmlNode is XmlComment)
+            {
+                DefineInlineFragmentParent((XmlComment)htmlNode, xamlParentElement);
+            }
+            else if (htmlNode is XmlText)
+            {
+                AddTextRun(xamlParentElement, htmlNode.Value);
+            }
+            else if (htmlNode is XmlElement)
+            {
+                var htmlElement = (XmlElement)htmlNode;
+
+                // Check whether this is an html element
+                if (htmlElement.NamespaceURI != HtmlParser.XhtmlNamespace)
+                {
+                    return; // Skip non-html elements
+                }
+
+                // Identify element name
+                var htmlElementName = htmlElement.LocalName.ToLower();
+
+                // Put source element to the stack
+                sourceContext.Add(htmlElement);
+
+                switch (htmlElementName)
+                {
+                    case "a":
+                        AddHyperlink(xamlParentElement, htmlElement, inheritedProperties, stylesheet, sourceContext);
+                        break;
+                    case "img":
+                        AddImage(xamlParentElement, htmlElement, inheritedProperties, stylesheet, sourceContext);
+                        break;
+                    case "br":
+                    case "hr":
+                        AddBreak(xamlParentElement, htmlElementName);
+                        break;
+                    default:
+                        if (HtmlSchema.IsInlineElement(htmlElementName) || HtmlSchema.IsBlockElement(htmlElementName))
+                        {
+                            // Note: actually we do not expect block elements here,
+                            // but if it happens to be here, we will treat it as a Span.
+
+                            AddSpanOrRun(xamlParentElement, htmlElement, inheritedProperties, stylesheet, sourceContext);
+                        }
+                        break;
+                }
+                // Ignore all other elements non-(block/inline/image)
+
+                // Remove the element from the stack
+                Debug.Assert(sourceContext.Count > 0 && sourceContext[sourceContext.Count - 1] == htmlElement);
+                sourceContext.RemoveAt(sourceContext.Count - 1);
+            }
+        }
+
+        private static void AddSpanOrRun(XmlElement xamlParentElement, XmlElement htmlElement,
+            Hashtable inheritedProperties,
+            CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            // Decide what XAML element to use for this inline element.
+            // Check whether it contains any nested inlines
+            var elementHasChildren = false;
+            for (var htmlNode = htmlElement.FirstChild; htmlNode != null; htmlNode = htmlNode.NextSibling)
+            {
+                if (htmlNode is XmlElement)
+                {
+                    var htmlChildName = ((XmlElement)htmlNode).LocalName.ToLower();
+                    if (HtmlSchema.IsInlineElement(htmlChildName) || HtmlSchema.IsBlockElement(htmlChildName) ||
+                        htmlChildName == "img" || htmlChildName == "br" || htmlChildName == "hr")
+                    {
+                        elementHasChildren = true;
+                        break;
+                    }
+                }
+            }
+
+            var xamlElementName = elementHasChildren ? XamlSpan : XamlRun;
+
+            // Create currentProperties as a compilation of local and inheritedProperties, set localProperties
+            Hashtable localProperties;
+            var currentProperties = GetElementProperties(htmlElement, inheritedProperties, out localProperties,
+                stylesheet,
+                sourceContext);
+
+            // Create a XAML element corresponding to this html element
+            var xamlElement = xamlParentElement.OwnerDocument.CreateElement( /*prefix:*/
+                null, /*localName:*/xamlElementName, XamlNamespace);
+            ApplyLocalProperties(xamlElement, localProperties, /*isBlock:*/false);
+
+            // Recurse into element subtree
+            for (var htmlChildNode = htmlElement.FirstChild;
+                htmlChildNode != null;
+                htmlChildNode = htmlChildNode.NextSibling)
+            {
+                AddInline(xamlElement, htmlChildNode, currentProperties, stylesheet, sourceContext);
+            }
+
+            // Add the new element to the parent.
+            xamlParentElement.AppendChild(xamlElement);
+        }
+
+        // Adds a text run to a xaml tree
+        private static void AddTextRun(XmlElement xamlElement, string textData)
+        {
+            // Remove control characters
+            for (var i = 0; i < textData.Length; i++)
+            {
+                if (char.IsControl(textData[i]))
+                {
+                    textData = textData.Remove(i--, 1); // decrement i to compensate for character removal
+                }
+            }
+
+            // Replace No-Breaks by spaces (160 is a code of &nbsp; entity in html)
+            //  This is a work around since WPF/XAML does not support &nbsp.
+            textData = textData.Replace((char)160, ' ');
+
+            if (textData.Length > 0)
+            {
+                xamlElement.AppendChild(xamlElement.OwnerDocument.CreateTextNode(textData));
+            }
+        }
+
+        private static void AddHyperlink(XmlElement xamlParentElement, XmlElement htmlElement,
+            Hashtable inheritedProperties,
+            CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            // Convert href attribute into NavigateUri and TargetName
+            var href = GetAttribute(htmlElement, "href");
+            if (href == null)
+            {
+                // When href attribute is missing - ignore the hyperlink
+                AddSpanOrRun(xamlParentElement, htmlElement, inheritedProperties, stylesheet, sourceContext);
+            }
+            else
+            {
+                // Create currentProperties as a compilation of local and inheritedProperties, set localProperties
+                Hashtable localProperties;
+                var currentProperties = GetElementProperties(htmlElement, inheritedProperties, out localProperties,
+                    stylesheet,
+                    sourceContext);
+
+                // Create a XAML element corresponding to this html element
+                var xamlElement = xamlParentElement.OwnerDocument.CreateElement( /*prefix:*/
+                    null, /*localName:*/XamlHyperlink, XamlNamespace);
+                ApplyLocalProperties(xamlElement, localProperties, /*isBlock:*/false);
+
+                var hrefParts = href.Split('#');
+                if (hrefParts.Length > 0 && hrefParts[0].Trim().Length > 0)
+                {
+                    xamlElement.SetAttribute(XamlHyperlinkNavigateUri, hrefParts[0].Trim());
+                }
+                if (hrefParts.Length == 2 && hrefParts[1].Trim().Length > 0)
+                {
+                    xamlElement.SetAttribute(XamlHyperlinkTargetName, hrefParts[1].Trim());
+                }
+
+                // Recurse into element subtree
+                for (var htmlChildNode = htmlElement.FirstChild;
+                    htmlChildNode != null;
+                    htmlChildNode = htmlChildNode.NextSibling)
+                {
+                    AddInline(xamlElement, htmlChildNode, currentProperties, stylesheet, sourceContext);
+                }
+
+                // Add the new element to the parent.
+                xamlParentElement.AppendChild(xamlElement);
+            }
+        }
+
+        // Stores a parent xaml element for the case when selected fragment is inline.
+        private static XmlElement _inlineFragmentParentElement;
+
+        // Called when html comment is encountered to store a parent element
+        // for the case when the fragment is inline - to extract it to a separate
+        // Span wrapper after the conversion.
+        private static void DefineInlineFragmentParent(XmlComment htmlComment, XmlElement xamlParentElement)
+        {
+            if (htmlComment.Value == "StartFragment")
+            {
+                _inlineFragmentParentElement = xamlParentElement;
+            }
+            else if (htmlComment.Value == "EndFragment")
+            {
+                if (_inlineFragmentParentElement == null && xamlParentElement != null)
+                {
+                    // Normally this cannot happen if comments produced by correct copying code
+                    // in Word or IE, but when it is produced manually then fragment boundary
+                    // markers can be inconsistent. In this case StartFragment takes precedence,
+                    // but if it is not set, then we get the value from EndFragment marker.
+                    _inlineFragmentParentElement = xamlParentElement;
+                }
+            }
+        }
+
+        // Extracts a content of an element stored as InlineFragmentParentElement
+        // into a separate Span wrapper.
+        // Note: when selected content does not cross paragraph boundaries,
+        // the fragment is marked within
+        private static XmlElement ExtractInlineFragment(XmlElement xamlFlowDocumentElement)
+        {
+            if (_inlineFragmentParentElement != null)
+            {
+                if (_inlineFragmentParentElement.LocalName == XamlSpan)
+                {
+                    xamlFlowDocumentElement = _inlineFragmentParentElement;
+                }
+                else
+                {
+                    xamlFlowDocumentElement = xamlFlowDocumentElement.OwnerDocument.CreateElement( /*prefix:*/
+                        null, /*localName:*/XamlSpan, XamlNamespace);
+                    while (_inlineFragmentParentElement.FirstChild != null)
+                    {
+                        var copyNode = _inlineFragmentParentElement.FirstChild;
+                        _inlineFragmentParentElement.RemoveChild(copyNode);
+                        xamlFlowDocumentElement.AppendChild(copyNode);
+                    }
+                }
+            }
+
+            return xamlFlowDocumentElement;
+        }
+
+        // .............................................................
+        //
+        // Images
+        //
+        // .............................................................
+
+        private static void AddImage(XmlElement xamlParentElement, XmlElement htmlElement, Hashtable inheritedProperties,
+            CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            //  Implement images
+        }
+
+        // .............................................................
+        //
+        // Lists
+        //
+        // .............................................................
+
+        /// <summary>
+        ///     Converts Html ul or ol element into Xaml list element. During conversion if the ul/ol element has any children
+        ///     that are not li elements, they are ignored and not added to the list element
+        /// </summary>
+        /// <param name="xamlParentElement">
+        ///     XmlElement representing Xaml parent to which the converted element should be added
+        /// </param>
+        /// <param name="htmlListElement">
+        ///     XmlElement representing Html ul/ol element to be converted
+        /// </param>
+        /// <param name="inheritedProperties">
+        ///     properties inherited from parent context
+        /// </param>
+        /// <param name="stylesheet"></param>
+        /// <param name="sourceContext"></param>
+        private static void AddList(XmlElement xamlParentElement, XmlElement htmlListElement,
+            Hashtable inheritedProperties,
+            CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            var htmlListElementName = htmlListElement.LocalName.ToLower();
+
+            Hashtable localProperties;
+            var currentProperties = GetElementProperties(htmlListElement, inheritedProperties, out localProperties,
+                stylesheet, sourceContext);
+
+            // Create Xaml List element
+            var xamlListElement = xamlParentElement.OwnerDocument.CreateElement(null, XamlList, XamlNamespace);
+
+            // Set default list markers
+            xamlListElement.SetAttribute(XamlListMarkerStyle,
+                htmlListElementName == "ol" ? XamlListMarkerStyleDecimal : XamlListMarkerStyleDisc);
+
+            // Apply local properties to list to set marker attribute if specified
+            // TODO: Should we have separate list attribute processing function?
+            ApplyLocalProperties(xamlListElement, localProperties, /*isBlock:*/true);
+
+            // Recurse into list subtree
+            for (var htmlChildNode = htmlListElement.FirstChild;
+                htmlChildNode != null;
+                htmlChildNode = htmlChildNode.NextSibling)
+            {
+                if (htmlChildNode is XmlElement && htmlChildNode.LocalName.ToLower() == "li")
+                {
+                    sourceContext.Add((XmlElement)htmlChildNode);
+                    AddListItem(xamlListElement, (XmlElement)htmlChildNode, currentProperties, stylesheet,
+                        sourceContext);
+                    Debug.Assert(sourceContext.Count > 0 && sourceContext[sourceContext.Count - 1] == htmlChildNode);
+                    sourceContext.RemoveAt(sourceContext.Count - 1);
+                }
+            }
+
+            // Add the List element to xaml tree - if it is not empty
+            if (xamlListElement.HasChildNodes)
+            {
+                xamlParentElement.AppendChild(xamlListElement);
+            }
+        }
+
+        /// <summary>
+        ///     If li items are found without a parent ul/ol element in Html string, creates xamlListElement as their parent and
+        ///     adds
+        ///     them to it. If the previously added node to the same xamlParentElement was a List, adds the elements to that list.
+        ///     Otherwise, we create a new xamlListElement and add them to it. Elements are added as long as li elements appear
+        ///     sequentially.
+        ///     The first non-li or text node stops the addition.
+        /// </summary>
+        /// <param name="xamlParentElement">
+        ///     Parent element for the list
+        /// </param>
+        /// <param name="htmlLiElement">
+        ///     Start Html li element without parent list
+        /// </param>
+        /// <param name="inheritedProperties">
+        ///     Properties inherited from parent context
+        /// </param>
+        /// <returns>
+        ///     XmlNode representing the first non-li node in the input after one or more li's have been processed.
+        /// </returns>
+        private static XmlElement AddOrphanListItems(XmlElement xamlParentElement, XmlElement htmlLiElement,
+            Hashtable inheritedProperties, CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            Debug.Assert(htmlLiElement.LocalName.ToLower() == "li");
+
+            XmlElement lastProcessedListItemElement = null;
+
+            // Find out the last element attached to the xamlParentElement, which is the previous sibling of this node
+            var xamlListItemElementPreviousSibling = xamlParentElement.LastChild;
+            XmlElement xamlListElement;
+            if (xamlListItemElementPreviousSibling != null && xamlListItemElementPreviousSibling.LocalName == XamlList)
+            {
+                // Previously added Xaml element was a list. We will add the new li to it
+                xamlListElement = (XmlElement)xamlListItemElementPreviousSibling;
+            }
+            else
+            {
+                // No list element near. Create our own.
+                xamlListElement = xamlParentElement.OwnerDocument.CreateElement(null, XamlList, XamlNamespace);
+                xamlParentElement.AppendChild(xamlListElement);
+            }
+
+            XmlNode htmlChildNode = htmlLiElement;
+            var htmlChildNodeName = htmlChildNode == null ? null : htmlChildNode.LocalName.ToLower();
+
+            //  Current element properties missed here.
+            //currentProperties = GetElementProperties(htmlLIElement, inheritedProperties, out localProperties, stylesheet);
+
+            // Add li elements to the parent xamlListElement we created as long as they appear sequentially
+            // Use properties inherited from xamlParentElement for context 
+            while (htmlChildNode != null && htmlChildNodeName == "li")
+            {
+                AddListItem(xamlListElement, (XmlElement)htmlChildNode, inheritedProperties, stylesheet, sourceContext);
+                lastProcessedListItemElement = (XmlElement)htmlChildNode;
+                htmlChildNode = htmlChildNode.NextSibling;
+                htmlChildNodeName = htmlChildNode?.LocalName.ToLower();
+            }
+
+            return lastProcessedListItemElement;
+        }
+
+        /// <summary>
+        ///     Converts htmlLIElement into Xaml ListItem element, and appends it to the parent xamlListElement
+        /// </summary>
+        /// <param name="xamlListElement">
+        ///     XmlElement representing Xaml List element to which the converted td/th should be added
+        /// </param>
+        /// <param name="htmlLiElement">
+        ///     XmlElement representing Html li element to be converted
+        /// </param>
+        /// <param name="inheritedProperties">
+        ///     Properties inherited from parent context
+        /// </param>
+        private static void AddListItem(XmlElement xamlListElement, XmlElement htmlLiElement,
+            Hashtable inheritedProperties,
+            CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            // Parameter validation
+            Debug.Assert(xamlListElement != null);
+            Debug.Assert(xamlListElement.LocalName == XamlList);
+            Debug.Assert(htmlLiElement != null);
+            Debug.Assert(htmlLiElement.LocalName.ToLower() == "li");
+            Debug.Assert(inheritedProperties != null);
+
+            Hashtable localProperties;
+            var currentProperties = GetElementProperties(htmlLiElement, inheritedProperties, out localProperties,
+                stylesheet, sourceContext);
+
+            var xamlListItemElement = xamlListElement.OwnerDocument.CreateElement(null, XamlListItem,
+                XamlNamespace);
+
+            // TODO: process local properties for li element
+
+            // Process children of the ListItem
+            for (var htmlChildNode = htmlLiElement.FirstChild;
+                htmlChildNode != null;
+                htmlChildNode = htmlChildNode?.NextSibling)
+            {
+                htmlChildNode = AddBlock(xamlListItemElement, htmlChildNode, currentProperties, stylesheet,
+                    sourceContext);
+            }
+
+            // Add resulting ListBoxItem to a xaml parent
+            xamlListElement.AppendChild(xamlListItemElement);
+        }
+
+        // .............................................................
+        //
+        // Tables
+        //
+        // .............................................................
+
+        /// <summary>
+        ///     Converts htmlTableElement to a Xaml Table element. Adds tbody elements if they are missing so
+        ///     that a resulting Xaml Table element is properly formed.
+        /// </summary>
+        /// <param name="xamlParentElement">
+        ///     Parent xaml element to which a converted table must be added.
+        /// </param>
+        /// <param name="htmlTableElement">
+        ///     XmlElement reprsenting the Html table element to be converted
+        /// </param>
+        /// <param name="inheritedProperties">
+        ///     Hashtable representing properties inherited from parent context.
+        /// </param>
+        private static void AddTable(XmlElement xamlParentElement, XmlElement htmlTableElement,
+            Hashtable inheritedProperties,
+            CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            // Parameter validation
+            Debug.Assert(htmlTableElement.LocalName.ToLower() == "table");
+            Debug.Assert(xamlParentElement != null);
+            Debug.Assert(inheritedProperties != null);
+
+            // Create current properties to be used by children as inherited properties, set local properties
+            Hashtable localProperties;
+            var currentProperties = GetElementProperties(htmlTableElement, inheritedProperties,
+                out localProperties,
+                stylesheet, sourceContext);
+
+            // TODO: process localProperties for tables to override defaults, decide cell spacing defaults
+
+            // Check if the table contains only one cell - we want to take only its content
+            var singleCell = GetCellFromSingleCellTable(htmlTableElement);
+
+            if (singleCell != null)
+            {
+                //  Need to push skipped table elements onto sourceContext
+                sourceContext.Add(singleCell);
+
+                // Add the cell's content directly to parent
+                for (var htmlChildNode = singleCell.FirstChild;
+                    htmlChildNode != null;
+                    htmlChildNode = htmlChildNode?.NextSibling)
+                {
+                    htmlChildNode = AddBlock(xamlParentElement, htmlChildNode, currentProperties, stylesheet,
+                        sourceContext);
+                }
+
+                Debug.Assert(sourceContext.Count > 0 && sourceContext[sourceContext.Count - 1] == singleCell);
+                sourceContext.RemoveAt(sourceContext.Count - 1);
+            }
+            else
+            {
+                // Create xamlTableElement
+                var xamlTableElement = xamlParentElement.OwnerDocument.CreateElement(null, XamlTable,
+                    XamlNamespace);
+
+                // Analyze table structure for column widths and rowspan attributes
+                var columnStarts = AnalyzeTableStructure(htmlTableElement, stylesheet);
+
+                // Process COLGROUP & COL elements
+                AddColumnInformation(htmlTableElement, xamlTableElement, columnStarts, currentProperties, stylesheet,
+                    sourceContext);
+
+                // Process table body - TBODY and TR elements
+                var htmlChildNode = htmlTableElement.FirstChild;
+
+                while (htmlChildNode != null)
+                {
+                    var htmlChildName = htmlChildNode.LocalName.ToLower();
+
+                    // Process the element
+                    if (htmlChildName == "tbody" || htmlChildName == "thead" || htmlChildName == "tfoot")
+                    {
+                        //  Add more special processing for TableHeader and TableFooter
+                        var xamlTableBodyElement = xamlTableElement.OwnerDocument.CreateElement(null,
+                            XamlTableRowGroup,
+                            XamlNamespace);
+                        xamlTableElement.AppendChild(xamlTableBodyElement);
+
+                        sourceContext.Add((XmlElement)htmlChildNode);
+
+                        // Get properties of Html tbody element
+                        Hashtable tbodyElementLocalProperties;
+                        var tbodyElementCurrentProperties = GetElementProperties((XmlElement)htmlChildNode,
+                            currentProperties,
+                            out tbodyElementLocalProperties, stylesheet, sourceContext);
+                        // TODO: apply local properties for tbody
+
+                        // Process children of htmlChildNode, which is tbody, for tr elements
+                        AddTableRowsToTableBody(xamlTableBodyElement, htmlChildNode.FirstChild,
+                            tbodyElementCurrentProperties,
+                            columnStarts, stylesheet, sourceContext);
+                        if (xamlTableBodyElement.HasChildNodes)
+                        {
+                            xamlTableElement.AppendChild(xamlTableBodyElement);
+                            // else: if there is no TRs in this TBody, we simply ignore it
+                        }
+
+                        Debug.Assert(sourceContext.Count > 0 && sourceContext[sourceContext.Count - 1] == htmlChildNode);
+                        sourceContext.RemoveAt(sourceContext.Count - 1);
+
+                        htmlChildNode = htmlChildNode.NextSibling;
+                    }
+                    else if (htmlChildName == "tr")
+                    {
+                        // Tbody is not present, but tr element is present. Tr is wrapped in tbody
+                        var xamlTableBodyElement = xamlTableElement.OwnerDocument.CreateElement(null,
+                            XamlTableRowGroup,
+                            XamlNamespace);
+
+                        // We use currentProperties of xamlTableElement when adding rows since the tbody element is artificially created and has 
+                        // no properties of its own
+
+                        htmlChildNode = AddTableRowsToTableBody(xamlTableBodyElement, htmlChildNode, currentProperties,
+                            columnStarts,
+                            stylesheet, sourceContext);
+                        if (xamlTableBodyElement.HasChildNodes)
+                        {
+                            xamlTableElement.AppendChild(xamlTableBodyElement);
+                        }
+                    }
+                    else
+                    {
+                        // Element is not tbody or tr. Ignore it.
+                        // TODO: add processing for thead, tfoot elements and recovery for td elements
+                        htmlChildNode = htmlChildNode.NextSibling;
+                    }
+                }
+
+                if (xamlTableElement.HasChildNodes)
+                {
+                    xamlParentElement.AppendChild(xamlTableElement);
+                }
+            }
+        }
+
+        private static XmlElement GetCellFromSingleCellTable(XmlElement htmlTableElement)
+        {
+            XmlElement singleCell = null;
+
+            for (var tableChild = htmlTableElement.FirstChild;
+                tableChild != null;
+                tableChild = tableChild.NextSibling)
+            {
+                var elementName = tableChild.LocalName.ToLower();
+                if (elementName == "tbody" || elementName == "thead" || elementName == "tfoot")
+                {
+                    if (singleCell != null)
+                    {
+                        return null;
+                    }
+                    for (var tbodyChild = tableChild.FirstChild;
+                        tbodyChild != null;
+                        tbodyChild = tbodyChild.NextSibling)
+                    {
+                        if (tbodyChild.LocalName.ToLower() == "tr")
+                        {
+                            if (singleCell != null)
+                            {
+                                return null;
+                            }
+                            for (var trChild = tbodyChild.FirstChild;
+                                trChild != null;
+                                trChild = trChild.NextSibling)
+                            {
+                                var cellName = trChild.LocalName.ToLower();
+                                if (cellName == "td" || cellName == "th")
+                                {
+                                    if (singleCell != null)
+                                    {
+                                        return null;
+                                    }
+                                    singleCell = (XmlElement)trChild;
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (tableChild.LocalName.ToLower() == "tr")
+                {
+                    if (singleCell != null)
+                    {
+                        return null;
+                    }
+                    for (var trChild = tableChild.FirstChild; trChild != null; trChild = trChild.NextSibling)
+                    {
+                        var cellName = trChild.LocalName.ToLower();
+                        if (cellName == "td" || cellName == "th")
+                        {
+                            if (singleCell != null)
+                            {
+                                return null;
+                            }
+                            singleCell = (XmlElement)trChild;
+                        }
+                    }
+                }
+            }
+
+            return singleCell;
+        }
+
+        /// <summary>
+        ///     Processes the information about table columns - COLGROUP and COL html elements.
+        /// </summary>
+        /// <param name="htmlTableElement">
+        ///     XmlElement representing a source html table.
+        /// </param>
+        /// <param name="xamlTableElement">
+        ///     XmlElement repesenting a resulting xaml table.
+        /// </param>
+        /// <param name="columnStartsAllRows">
+        ///     Array of doubles - column start coordinates.
+        ///     Can be null, which means that column size information is not available
+        ///     and we must use source colgroup/col information.
+        ///     In case wneh it's not null, we will ignore source colgroup/col information.
+        /// </param>
+        /// <param name="currentProperties"></param>
+        /// <param name="stylesheet"></param>
+        /// <param name="sourceContext"></param>
+        private static void AddColumnInformation(XmlElement htmlTableElement, XmlElement xamlTableElement,
+            ArrayList columnStartsAllRows, Hashtable currentProperties, CssStylesheet stylesheet,
+            List<XmlElement> sourceContext)
+        {
+            // Add column information
+            if (columnStartsAllRows != null)
+            {
+                // We have consistent information derived from table cells; use it
+                // The last element in columnStarts represents the end of the table
+                for (var columnIndex = 0; columnIndex < columnStartsAllRows.Count - 1; columnIndex++)
+                {
+                    XmlElement xamlColumnElement;
+
+                    xamlColumnElement = xamlTableElement.OwnerDocument.CreateElement(null, XamlTableColumn,
+                        XamlNamespace);
+                    xamlColumnElement.SetAttribute(XamlWidth,
+                        ((double)columnStartsAllRows[columnIndex + 1] - (double)columnStartsAllRows[columnIndex])
+                            .ToString(CultureInfo.InvariantCulture));
+                    xamlTableElement.AppendChild(xamlColumnElement);
+                }
+            }
+            else
+            {
+                // We do not have consistent information from table cells;
+                // Translate blindly colgroups from html.                
+                for (var htmlChildNode = htmlTableElement.FirstChild;
+                    htmlChildNode != null;
+                    htmlChildNode = htmlChildNode.NextSibling)
+                {
+                    if (htmlChildNode.LocalName.ToLower() == "colgroup")
+                    {
+                        // TODO: add column width information to this function as a parameter and process it
+                        AddTableColumnGroup(xamlTableElement, (XmlElement)htmlChildNode, currentProperties, stylesheet,
+                            sourceContext);
+                    }
+                    else if (htmlChildNode.LocalName.ToLower() == "col")
+                    {
+                        AddTableColumn(xamlTableElement, (XmlElement)htmlChildNode, currentProperties, stylesheet,
+                            sourceContext);
+                    }
+                    else if (htmlChildNode is XmlElement)
+                    {
+                        // Some element which belongs to table body. Stop column loop.
+                        break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Converts htmlColgroupElement into Xaml TableColumnGroup element, and appends it to the parent
+        ///     xamlTableElement
+        /// </summary>
+        /// <param name="xamlTableElement">
+        ///     XmlElement representing Xaml Table element to which the converted column group should be added
+        /// </param>
+        /// <param name="htmlColgroupElement">
+        ///     XmlElement representing Html colgroup element to be converted
+        ///     <param name="inheritedProperties">
+        ///         Properties inherited from parent context
+        ///     </param>
+        private static void AddTableColumnGroup(XmlElement xamlTableElement, XmlElement htmlColgroupElement,
+            Hashtable inheritedProperties, CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            Hashtable localProperties;
+            var currentProperties = GetElementProperties(htmlColgroupElement, inheritedProperties,
+                out localProperties,
+                stylesheet, sourceContext);
+
+            // TODO: process local properties for colgroup
+
+            // Process children of colgroup. Colgroup may contain only col elements.
+            for (var htmlNode = htmlColgroupElement.FirstChild; htmlNode != null; htmlNode = htmlNode.NextSibling)
+            {
+                if (htmlNode is XmlElement && htmlNode.LocalName.ToLower() == "col")
+                {
+                    AddTableColumn(xamlTableElement, (XmlElement)htmlNode, currentProperties, stylesheet, sourceContext);
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Converts htmlColElement into Xaml TableColumn element, and appends it to the parent
+        ///     xamlTableColumnGroupElement
+        /// </summary>
+        /// <param name="xamlTableElement"></param>
+        /// <param name="htmlColElement">
+        ///     XmlElement representing Html col element to be converted
+        /// </param>
+        /// <param name="inheritedProperties">
+        ///     properties inherited from parent context
+        /// </param>
+        /// <param name="stylesheet"></param>
+        /// <param name="sourceContext"></param>
+        private static void AddTableColumn(XmlElement xamlTableElement, XmlElement htmlColElement,
+            Hashtable inheritedProperties, CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            Hashtable localProperties;
+            var currentProperties = GetElementProperties(htmlColElement, inheritedProperties, out localProperties,
+                stylesheet, sourceContext);
+
+            var xamlTableColumnElement = xamlTableElement.OwnerDocument.CreateElement(null, XamlTableColumn,
+                XamlNamespace);
+
+            // TODO: process local properties for TableColumn element
+
+            // Col is an empty element, with no subtree 
+            xamlTableElement.AppendChild(xamlTableColumnElement);
+        }
+
+        /// <summary>
+        ///     Adds TableRow elements to xamlTableBodyElement. The rows are converted from Html tr elements that
+        ///     may be the children of an Html tbody element or an Html table element with tbody missing
+        /// </summary>
+        /// <param name="xamlTableBodyElement">
+        ///     XmlElement representing Xaml TableRowGroup element to which the converted rows should be added
+        /// </param>
+        /// <param name="htmlTrStartNode">
+        ///     XmlElement representing the first tr child of the tbody element to be read
+        /// </param>
+        /// <param name="currentProperties">
+        ///     Hashtable representing current properties of the tbody element that are generated and applied in the
+        ///     AddTable function; to be used as inheritedProperties when adding tr elements
+        /// </param>
+        /// <param name="columnStarts"></param>
+        /// <param name="stylesheet"></param>
+        /// <param name="sourceContext"></param>
+        /// <returns>
+        ///     XmlNode representing the current position of the iterator among tr elements
+        /// </returns>
+        private static XmlNode AddTableRowsToTableBody(XmlElement xamlTableBodyElement, XmlNode htmlTrStartNode,
+            Hashtable currentProperties, ArrayList columnStarts, CssStylesheet stylesheet,
+            List<XmlElement> sourceContext)
+        {
+            // Parameter validation
+            Debug.Assert(xamlTableBodyElement.LocalName == XamlTableRowGroup);
+            Debug.Assert(currentProperties != null);
+
+            // Initialize child node for iteratimg through children to the first tr element
+            var htmlChildNode = htmlTrStartNode;
+            ArrayList activeRowSpans = null;
+            if (columnStarts != null)
+            {
+                activeRowSpans = new ArrayList();
+                InitializeActiveRowSpans(activeRowSpans, columnStarts.Count);
+            }
+
+            while (htmlChildNode != null && htmlChildNode.LocalName.ToLower() != "tbody")
+            {
+                if (htmlChildNode.LocalName.ToLower() == "tr")
+                {
+                    var xamlTableRowElement = xamlTableBodyElement.OwnerDocument.CreateElement(null,
+                        XamlTableRow,
+                        XamlNamespace);
+
+                    sourceContext.Add((XmlElement)htmlChildNode);
+
+                    // Get tr element properties
+                    Hashtable trElementLocalProperties;
+                    var trElementCurrentProperties = GetElementProperties((XmlElement)htmlChildNode,
+                        currentProperties,
+                        out trElementLocalProperties, stylesheet, sourceContext);
+                    // TODO: apply local properties to tr element
+
+                    AddTableCellsToTableRow(xamlTableRowElement, htmlChildNode.FirstChild, trElementCurrentProperties,
+                        columnStarts,
+                        activeRowSpans, stylesheet, sourceContext);
+                    if (xamlTableRowElement.HasChildNodes)
+                    {
+                        xamlTableBodyElement.AppendChild(xamlTableRowElement);
+                    }
+
+                    Debug.Assert(sourceContext.Count > 0 && sourceContext[sourceContext.Count - 1] == htmlChildNode);
+                    sourceContext.RemoveAt(sourceContext.Count - 1);
+
+                    // Advance
+                    htmlChildNode = htmlChildNode.NextSibling;
+                }
+                else if (htmlChildNode.LocalName.ToLower() == "td")
+                {
+                    // Tr element is not present. We create one and add td elements to it
+                    var xamlTableRowElement = xamlTableBodyElement.OwnerDocument.CreateElement(null,
+                        XamlTableRow,
+                        XamlNamespace);
+
+                    // This is incorrect formatting and the column starts should not be set in this case
+                    Debug.Assert(columnStarts == null);
+
+                    htmlChildNode = AddTableCellsToTableRow(xamlTableRowElement, htmlChildNode, currentProperties,
+                        columnStarts,
+                        activeRowSpans, stylesheet, sourceContext);
+                    if (xamlTableRowElement.HasChildNodes)
+                    {
+                        xamlTableBodyElement.AppendChild(xamlTableRowElement);
+                    }
+                }
+                else
+                {
+                    // Not a tr or td  element. Ignore it.
+                    // TODO: consider better recovery here
+                    htmlChildNode = htmlChildNode.NextSibling;
+                }
+            }
+            return htmlChildNode;
+        }
+
+        /// <summary>
+        ///     Adds TableCell elements to xamlTableRowElement.
+        /// </summary>
+        /// <param name="xamlTableRowElement">
+        ///     XmlElement representing Xaml TableRow element to which the converted cells should be added
+        /// </param>
+        /// <param name="htmlTdStartNode">
+        ///     XmlElement representing the child of tr or tbody element from which we should start adding td elements
+        /// </param>
+        /// <param name="currentProperties">
+        ///     properties of the current html tr element to which cells are to be added
+        /// </param>
+        /// <returns>
+        ///     XmlElement representing the current position of the iterator among the children of the parent Html tbody/tr element
+        /// </returns>
+        private static XmlNode AddTableCellsToTableRow(XmlElement xamlTableRowElement, XmlNode htmlTdStartNode,
+            Hashtable currentProperties, ArrayList columnStarts, ArrayList activeRowSpans, CssStylesheet stylesheet,
+            List<XmlElement> sourceContext)
+        {
+            // parameter validation
+            Debug.Assert(xamlTableRowElement.LocalName == XamlTableRow);
+            Debug.Assert(currentProperties != null);
+            if (columnStarts != null)
+            {
+                Debug.Assert(activeRowSpans.Count == columnStarts.Count);
+            }
+
+            var htmlChildNode = htmlTdStartNode;
+            double columnStart = 0;
+            double columnWidth = 0;
+            var columnIndex = 0;
+            var columnSpan = 0;
+
+            while (htmlChildNode != null && htmlChildNode.LocalName.ToLower() != "tr" &&
+                   htmlChildNode.LocalName.ToLower() != "tbody" && htmlChildNode.LocalName.ToLower() != "thead" &&
+                   htmlChildNode.LocalName.ToLower() != "tfoot")
+            {
+                if (htmlChildNode.LocalName.ToLower() == "td" || htmlChildNode.LocalName.ToLower() == "th")
+                {
+                    var xamlTableCellElement = xamlTableRowElement.OwnerDocument.CreateElement(null,
+                        XamlTableCell,
+                        XamlNamespace);
+
+                    sourceContext.Add((XmlElement)htmlChildNode);
+
+                    Hashtable tdElementLocalProperties;
+                    var tdElementCurrentProperties = GetElementProperties((XmlElement)htmlChildNode,
+                        currentProperties,
+                        out tdElementLocalProperties, stylesheet, sourceContext);
+
+                    // TODO: determine if localProperties can be used instead of htmlChildNode in this call, and if they can,
+                    // make necessary changes and use them instead.
+                    ApplyPropertiesToTableCellElement((XmlElement)htmlChildNode, xamlTableCellElement);
+
+                    if (columnStarts != null)
+                    {
+                        Debug.Assert(columnIndex < columnStarts.Count - 1);
+                        while (columnIndex < activeRowSpans.Count && (int)activeRowSpans[columnIndex] > 0)
+                        {
+                            activeRowSpans[columnIndex] = (int)activeRowSpans[columnIndex] - 1;
+                            Debug.Assert((int)activeRowSpans[columnIndex] >= 0);
+                            columnIndex++;
+                        }
+                        Debug.Assert(columnIndex < columnStarts.Count - 1);
+                        columnStart = (double)columnStarts[columnIndex];
+                        columnWidth = GetColumnWidth((XmlElement)htmlChildNode);
+                        columnSpan = CalculateColumnSpan(columnIndex, columnWidth, columnStarts);
+                        var rowSpan = GetRowSpan((XmlElement)htmlChildNode);
+
+                        // Column cannot have no span
+                        Debug.Assert(columnSpan > 0);
+                        Debug.Assert(columnIndex + columnSpan < columnStarts.Count);
+
+                        xamlTableCellElement.SetAttribute(XamlTableCellColumnSpan, columnSpan.ToString());
+
+                        // Apply row span
+                        for (var spannedColumnIndex = columnIndex;
+                            spannedColumnIndex < columnIndex + columnSpan;
+                            spannedColumnIndex++)
+                        {
+                            Debug.Assert(spannedColumnIndex < activeRowSpans.Count);
+                            activeRowSpans[spannedColumnIndex] = (rowSpan - 1);
+                            Debug.Assert((int)activeRowSpans[spannedColumnIndex] >= 0);
+                        }
+
+                        columnIndex = columnIndex + columnSpan;
+                    }
+
+                    AddDataToTableCell(xamlTableCellElement, htmlChildNode.FirstChild, tdElementCurrentProperties,
+                        stylesheet,
+                        sourceContext);
+                    if (xamlTableCellElement.HasChildNodes)
+                    {
+                        xamlTableRowElement.AppendChild(xamlTableCellElement);
+                    }
+
+                    Debug.Assert(sourceContext.Count > 0 && sourceContext[sourceContext.Count - 1] == htmlChildNode);
+                    sourceContext.RemoveAt(sourceContext.Count - 1);
+
+                    htmlChildNode = htmlChildNode.NextSibling;
+                }
+                else
+                {
+                    // Not td element. Ignore it.
+                    // TODO: Consider better recovery
+                    htmlChildNode = htmlChildNode.NextSibling;
+                }
+            }
+            return htmlChildNode;
+        }
+
+        /// <summary>
+        ///     adds table cell data to xamlTableCellElement
+        /// </summary>
+        /// <param name="xamlTableCellElement">
+        ///     XmlElement representing Xaml TableCell element to which the converted data should be added
+        /// </param>
+        /// <param name="htmlDataStartNode">
+        ///     XmlElement representing the start element of data to be added to xamlTableCellElement
+        /// </param>
+        /// <param name="currentProperties">
+        ///     Current properties for the html td/th element corresponding to xamlTableCellElement
+        /// </param>
+        private static void AddDataToTableCell(XmlElement xamlTableCellElement, XmlNode htmlDataStartNode,
+            Hashtable currentProperties, CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            // Parameter validation
+            Debug.Assert(xamlTableCellElement.LocalName == XamlTableCell);
+            Debug.Assert(currentProperties != null);
+
+            for (var htmlChildNode = htmlDataStartNode;
+                htmlChildNode != null;
+                htmlChildNode = htmlChildNode?.NextSibling)
+            {
+                // Process a new html element and add it to the td element
+                htmlChildNode = AddBlock(xamlTableCellElement, htmlChildNode, currentProperties, stylesheet,
+                    sourceContext);
+            }
+        }
+
+        /// <summary>
+        ///     Performs a parsing pass over a table to read information about column width and rowspan attributes. This
+        ///     information
+        ///     is used to determine the starting point of each column.
+        /// </summary>
+        /// <param name="htmlTableElement">
+        ///     XmlElement representing Html table whose structure is to be analyzed
+        /// </param>
+        /// <returns>
+        ///     ArrayList of type double which contains the function output. If analysis is successful, this ArrayList contains
+        ///     all the points which are the starting position of any column in the table, ordered from left to right.
+        ///     In case if analisys was impossible we return null.
+        /// </returns>
+        private static ArrayList AnalyzeTableStructure(XmlElement htmlTableElement, CssStylesheet stylesheet)
+        {
+            // Parameter validation
+            Debug.Assert(htmlTableElement.LocalName.ToLower() == "table");
+            if (!htmlTableElement.HasChildNodes)
+            {
+                return null;
+            }
+
+            var columnWidthsAvailable = true;
+
+            var columnStarts = new ArrayList();
+            var activeRowSpans = new ArrayList();
+            Debug.Assert(columnStarts.Count == activeRowSpans.Count);
+
+            var htmlChildNode = htmlTableElement.FirstChild;
+            double tableWidth = 0; // Keep track of table width which is the width of its widest row
+
+            // Analyze tbody and tr elements
+            while (htmlChildNode != null && columnWidthsAvailable)
+            {
+                Debug.Assert(columnStarts.Count == activeRowSpans.Count);
+
+                switch (htmlChildNode.LocalName.ToLower())
+                {
+                    case "tbody":
+                        // Tbody element, we should analyze its children for trows
+                        var tbodyWidth = AnalyzeTbodyStructure((XmlElement)htmlChildNode, columnStarts,
+                            activeRowSpans, tableWidth,
+                            stylesheet);
+                        if (tbodyWidth > tableWidth)
+                        {
+                            // Table width must be increased to supported newly added wide row
+                            tableWidth = tbodyWidth;
+                        }
+                        else if (tbodyWidth == 0)
+                        {
+                            // Tbody analysis may return 0, probably due to unprocessable format. 
+                            // We should also fail.
+                            columnWidthsAvailable = false; // interrupt the analisys
+                        }
+                        break;
+                    case "tr":
+                        // Table row. Analyze column structure within row directly
+                        var trWidth = AnalyzeTrStructure((XmlElement)htmlChildNode, columnStarts, activeRowSpans,
+                            tableWidth,
+                            stylesheet);
+                        if (trWidth > tableWidth)
+                        {
+                            tableWidth = trWidth;
+                        }
+                        else if (trWidth == 0)
+                        {
+                            columnWidthsAvailable = false; // interrupt the analisys
+                        }
+                        break;
+                    case "td":
+                        // Incorrect formatting, too deep to analyze at this level. Return null.
+                        // TODO: implement analysis at this level, possibly by creating a new tr
+                        columnWidthsAvailable = false; // interrupt the analisys
+                        break;
+                    default:
+                        // Element should not occur directly in table. Ignore it.
+                        break;
+                }
+
+                htmlChildNode = htmlChildNode.NextSibling;
+            }
+
+            if (columnWidthsAvailable)
+            {
+                // Add an item for whole table width
+                columnStarts.Add(tableWidth);
+                VerifyColumnStartsAscendingOrder(columnStarts);
+            }
+            else
+            {
+                columnStarts = null;
+            }
+
+            return columnStarts;
+        }
+
+        /// <summary>
+        ///     Performs a parsing pass over a tbody to read information about column width and rowspan attributes. Information
+        ///     read about width
+        ///     attributes is stored in the reference ArrayList parameter columnStarts, which contains a list of all starting
+        ///     positions of all columns in the table, ordered from left to right. Row spans are taken into consideration when
+        ///     computing column starts
+        /// </summary>
+        /// <param name="htmlTbodyElement">
+        ///     XmlElement representing Html tbody whose structure is to be analyzed
+        /// </param>
+        /// <param name="columnStarts">
+        ///     ArrayList of type double which contains the function output. If analysis fails, this parameter is set to null
+        /// </param>
+        /// <param name="tableWidth">
+        ///     Current width of the table. This is used to determine if a new column when added to the end of table should
+        ///     come after the last column in the table or is actually splitting the last column in two. If it is only splitting
+        ///     the last column it should inherit row span for that column
+        /// </param>
+        /// <returns>
+        ///     Calculated width of a tbody.
+        ///     In case of non-analizable column width structure return 0;
+        /// </returns>
+        private static double AnalyzeTbodyStructure(XmlElement htmlTbodyElement, ArrayList columnStarts,
+            ArrayList activeRowSpans, double tableWidth, CssStylesheet stylesheet)
+        {
+            // Parameter validation
+            Debug.Assert(htmlTbodyElement.LocalName.ToLower() == "tbody");
+            Debug.Assert(columnStarts != null);
+
+            double tbodyWidth = 0;
+            var columnWidthsAvailable = true;
+
+            if (!htmlTbodyElement.HasChildNodes)
+            {
+                return tbodyWidth;
+            }
+
+            // Set active row spans to 0 - thus ignoring row spans crossing tbody boundaries
+            ClearActiveRowSpans(activeRowSpans);
+
+            var htmlChildNode = htmlTbodyElement.FirstChild;
+
+            // Analyze tr elements
+            while (htmlChildNode != null && columnWidthsAvailable)
+            {
+                switch (htmlChildNode.LocalName.ToLower())
+                {
+                    case "tr":
+                        var trWidth = AnalyzeTrStructure((XmlElement)htmlChildNode, columnStarts, activeRowSpans,
+                            tbodyWidth,
+                            stylesheet);
+                        if (trWidth > tbodyWidth)
+                        {
+                            tbodyWidth = trWidth;
+                        }
+                        break;
+                    case "td":
+                        columnWidthsAvailable = false; // interrupt the analisys
+                        break;
+                    default:
+                        break;
+                }
+                htmlChildNode = htmlChildNode.NextSibling;
+            }
+
+            // Set active row spans to 0 - thus ignoring row spans crossing tbody boundaries
+            ClearActiveRowSpans(activeRowSpans);
+
+            return columnWidthsAvailable ? tbodyWidth : 0;
+        }
+
+        /// <summary>
+        ///     Performs a parsing pass over a tr element to read information about column width and rowspan attributes.
+        /// </summary>
+        /// <param name="htmlTrElement">
+        ///     XmlElement representing Html tr element whose structure is to be analyzed
+        /// </param>
+        /// <param name="columnStarts">
+        ///     ArrayList of type double which contains the function output. If analysis is successful, this ArrayList contains
+        ///     all the points which are the starting position of any column in the tr, ordered from left to right. If analysis
+        ///     fails,
+        ///     the ArrayList is set to null
+        /// </param>
+        /// <param name="activeRowSpans">
+        ///     ArrayList representing all columns currently spanned by an earlier row span attribute. These columns should
+        ///     not be used for data in this row. The ArrayList actually contains notation for all columns in the table, if the
+        ///     active row span is set to 0 that column is not presently spanned but if it is > 0 the column is presently spanned
+        /// </param>
+        /// <param name="tableWidth">
+        ///     Double value representing the current width of the table.
+        ///     Return 0 if analisys was insuccessful.
+        /// </param>
+        private static double AnalyzeTrStructure(XmlElement htmlTrElement, ArrayList columnStarts,
+            ArrayList activeRowSpans,
+            double tableWidth, CssStylesheet stylesheet)
+        {
+            double columnWidth;
+
+            // Parameter validation
+            Debug.Assert(htmlTrElement.LocalName.ToLower() == "tr");
+            Debug.Assert(columnStarts != null);
+            Debug.Assert(activeRowSpans != null);
+            Debug.Assert(columnStarts.Count == activeRowSpans.Count);
+
+            if (!htmlTrElement.HasChildNodes)
+            {
+                return 0;
+            }
+
+            var columnWidthsAvailable = true;
+
+            double columnStart = 0; // starting position of current column
+            var htmlChildNode = htmlTrElement.FirstChild;
+            var columnIndex = 0;
+            double trWidth = 0;
+
+            // Skip spanned columns to get to real column start
+            if (columnIndex < activeRowSpans.Count)
+            {
+                Debug.Assert((double)columnStarts[columnIndex] >= columnStart);
+                if ((double)columnStarts[columnIndex] == columnStart)
+                {
+                    // The new column may be in a spanned area
+                    while (columnIndex < activeRowSpans.Count && (int)activeRowSpans[columnIndex] > 0)
+                    {
+                        activeRowSpans[columnIndex] = (int)activeRowSpans[columnIndex] - 1;
+                        Debug.Assert((int)activeRowSpans[columnIndex] >= 0);
+                        columnIndex++;
+                        columnStart = (double)columnStarts[columnIndex];
+                    }
+                }
+            }
+
+            while (htmlChildNode != null && columnWidthsAvailable)
+            {
+                Debug.Assert(columnStarts.Count == activeRowSpans.Count);
+
+                VerifyColumnStartsAscendingOrder(columnStarts);
+
+                switch (htmlChildNode.LocalName.ToLower())
+                {
+                    case "td":
+                        Debug.Assert(columnIndex <= columnStarts.Count);
+                        if (columnIndex < columnStarts.Count)
+                        {
+                            Debug.Assert(columnStart <= (double)columnStarts[columnIndex]);
+                            if (columnStart < (double)columnStarts[columnIndex])
+                            {
+                                columnStarts.Insert(columnIndex, columnStart);
+                                // There can be no row spans now - the column data will appear here
+                                // Row spans may appear only during the column analysis
+                                activeRowSpans.Insert(columnIndex, 0);
+                            }
+                        }
+                        else
+                        {
+                            // Column start is greater than all previous starts. Row span must still be 0 because
+                            // we are either adding after another column of the same row, in which case it should not inherit
+                            // the previous column's span. Otherwise we are adding after the last column of some previous
+                            // row, and assuming the table widths line up, we should not be spanned by it. If there is
+                            // an incorrect tbale structure where a columns starts in the middle of a row span, we do not
+                            // guarantee correct output
+                            columnStarts.Add(columnStart);
+                            activeRowSpans.Add(0);
+                        }
+                        columnWidth = GetColumnWidth((XmlElement)htmlChildNode);
+                        if (columnWidth != -1)
+                        {
+                            int nextColumnIndex;
+                            var rowSpan = GetRowSpan((XmlElement)htmlChildNode);
+
+                            nextColumnIndex = GetNextColumnIndex(columnIndex, columnWidth, columnStarts, activeRowSpans);
+                            if (nextColumnIndex != -1)
+                            {
+                                // Entire column width can be processed without hitting conflicting row span. This means that
+                                // column widths line up and we can process them
+                                Debug.Assert(nextColumnIndex <= columnStarts.Count);
+
+                                // Apply row span to affected columns
+                                for (var spannedColumnIndex = columnIndex;
+                                    spannedColumnIndex < nextColumnIndex;
+                                    spannedColumnIndex++)
+                                {
+                                    activeRowSpans[spannedColumnIndex] = rowSpan - 1;
+                                    Debug.Assert((int)activeRowSpans[spannedColumnIndex] >= 0);
+                                }
+
+                                columnIndex = nextColumnIndex;
+
+                                // Calculate columnsStart for the next cell
+                                columnStart = columnStart + columnWidth;
+
+                                if (columnIndex < activeRowSpans.Count)
+                                {
+                                    Debug.Assert((double)columnStarts[columnIndex] >= columnStart);
+                                    if ((double)columnStarts[columnIndex] == columnStart)
+                                    {
+                                        // The new column may be in a spanned area
+                                        while (columnIndex < activeRowSpans.Count &&
+                                               (int)activeRowSpans[columnIndex] > 0)
+                                        {
+                                            activeRowSpans[columnIndex] = (int)activeRowSpans[columnIndex] - 1;
+                                            Debug.Assert((int)activeRowSpans[columnIndex] >= 0);
+                                            columnIndex++;
+                                            columnStart = (double)columnStarts[columnIndex];
+                                        }
+                                    }
+                                    // else: the new column does not start at the same time as a pre existing column
+                                    // so we don't have to check it for active row spans, it starts in the middle
+                                    // of another column which has been checked already by the GetNextColumnIndex function
+                                }
+                            }
+                            else
+                            {
+                                // Full column width cannot be processed without a pre existing row span.
+                                // We cannot analyze widths
+                                columnWidthsAvailable = false;
+                            }
+                        }
+                        else
+                        {
+                            // Incorrect column width, stop processing
+                            columnWidthsAvailable = false;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+
+                htmlChildNode = htmlChildNode.NextSibling;
+            }
+
+            // The width of the tr element is the position at which it's last td element ends, which is calculated in
+            // the columnStart value after each td element is processed
+            trWidth = columnWidthsAvailable ? columnStart : 0;
+
+            return trWidth;
+        }
+
+        /// <summary>
+        ///     Gets row span attribute from htmlTDElement. Returns an integer representing the value of the rowspan attribute.
+        ///     Default value if attribute is not specified or if it is invalid is 1
+        /// </summary>
+        /// <param name="htmlTdElement">
+        ///     Html td element to be searched for rowspan attribute
+        /// </param>
+        private static int GetRowSpan(XmlElement htmlTdElement)
+        {
+            string rowSpanAsString;
+            int rowSpan;
+
+            rowSpanAsString = GetAttribute(htmlTdElement, "rowspan");
+            if (rowSpanAsString != null)
+            {
+                if (!int.TryParse(rowSpanAsString, out rowSpan))
+                {
+                    // Ignore invalid value of rowspan; treat it as 1
+                    rowSpan = 1;
+                }
+            }
+            else
+            {
+                // No row span, default is 1
+                rowSpan = 1;
+            }
+            return rowSpan;
+        }
+
+        /// <summary>
+        ///     Gets index at which a column should be inseerted into the columnStarts ArrayList. This is
+        ///     decided by the value columnStart. The columnStarts ArrayList is ordered in ascending order.
+        ///     Returns an integer representing the index at which the column should be inserted
+        /// </summary>
+        /// <param name="columnStarts">
+        ///     Array list representing starting coordinates of all columns in the table
+        /// </param>
+        /// <param name="columnStart">
+        ///     Starting coordinate of column we wish to insert into columnStart
+        /// </param>
+        /// <param name="columnIndex">
+        ///     Int representing the current column index. This acts as a clue while finding the insertion index.
+        ///     If the value of columnStarts at columnIndex is the same as columnStart, then this position alrady exists
+        ///     in the array and we can jsut return columnIndex.
+        /// </param>
+        /// <returns></returns>
+        private static int GetNextColumnIndex(int columnIndex, double columnWidth, ArrayList columnStarts,
+            ArrayList activeRowSpans)
+        {
+            double columnStart;
+            int spannedColumnIndex;
+
+            // Parameter validation
+            Debug.Assert(columnStarts != null);
+            Debug.Assert(0 <= columnIndex && columnIndex <= columnStarts.Count);
+            Debug.Assert(columnWidth > 0);
+
+            columnStart = (double)columnStarts[columnIndex];
+            spannedColumnIndex = columnIndex + 1;
+
+            while (spannedColumnIndex < columnStarts.Count &&
+                   (double)columnStarts[spannedColumnIndex] < columnStart + columnWidth && spannedColumnIndex != -1)
+            {
+                if ((int)activeRowSpans[spannedColumnIndex] > 0)
+                {
+                    // The current column should span this area, but something else is already spanning it
+                    // Not analyzable
+                    spannedColumnIndex = -1;
+                }
+                else
+                {
+                    spannedColumnIndex++;
+                }
+            }
+
+            return spannedColumnIndex;
+        }
+
+
+        /// <summary>
+        ///     Used for clearing activeRowSpans array in the beginning/end of each tbody
+        /// </summary>
+        /// <param name="activeRowSpans">
+        ///     ArrayList representing currently active row spans
+        /// </param>
+        private static void ClearActiveRowSpans(ArrayList activeRowSpans)
+        {
+            for (var columnIndex = 0; columnIndex < activeRowSpans.Count; columnIndex++)
+            {
+                activeRowSpans[columnIndex] = 0;
+            }
+        }
+
+        /// <summary>
+        ///     Used for initializing activeRowSpans array in the before adding rows to tbody element
+        /// </summary>
+        /// <param name="activeRowSpans">
+        ///     ArrayList representing currently active row spans
+        /// </param>
+        /// <param name="count">
+        ///     Size to be give to array list
+        /// </param>
+        private static void InitializeActiveRowSpans(ArrayList activeRowSpans, int count)
+        {
+            for (var columnIndex = 0; columnIndex < count; columnIndex++)
+            {
+                activeRowSpans.Add(0);
+            }
+        }
+
+
+        /// <summary>
+        ///     Calculates width of next TD element based on starting position of current element and it's width, which
+        ///     is calculated byt he function
+        /// </summary>
+        /// <param name="htmlTdElement">
+        ///     XmlElement representing Html td element whose width is to be read
+        /// </param>
+        /// <param name="columnStart">
+        ///     Starting position of current column
+        /// </param>
+        private static double GetNextColumnStart(XmlElement htmlTdElement, double columnStart)
+        {
+            double columnWidth;
+            double nextColumnStart;
+
+            // Parameter validation
+            Debug.Assert(htmlTdElement.LocalName.ToLower() == "td" || htmlTdElement.LocalName.ToLower() == "th");
+            Debug.Assert(columnStart >= 0);
+
+            nextColumnStart = -1; // -1 indicates inability to calculate columnStart width
+
+            columnWidth = GetColumnWidth(htmlTdElement);
+
+            if (columnWidth == -1)
+            {
+                nextColumnStart = -1;
+            }
+            else
+            {
+                nextColumnStart = columnStart + columnWidth;
+            }
+
+            return nextColumnStart;
+        }
+
+
+        private static double GetColumnWidth(XmlElement htmlTdElement)
+        {
+            string columnWidthAsString;
+            double columnWidth;
+
+            columnWidthAsString = null;
+            columnWidth = -1;
+
+            // Get string valkue for the width
+            columnWidthAsString = GetAttribute(htmlTdElement, "width") ??
+                                  GetCssAttribute(GetAttribute(htmlTdElement, "style"), "width");
+
+            // We do not allow column width to be 0, if specified as 0 we will fail to record it
+            if (!TryGetLengthValue(columnWidthAsString, out columnWidth) || columnWidth == 0)
+            {
+                columnWidth = -1;
+            }
+            return columnWidth;
+        }
+
+        /// <summary>
+        ///     Calculates column span based the column width and the widths of all other columns. Returns an integer representing
+        ///     the column span
+        /// </summary>
+        /// <param name="columnIndex">
+        ///     Index of the current column
+        /// </param>
+        /// <param name="columnWidth">
+        ///     Width of the current column
+        /// </param>
+        /// <param name="columnStarts">
+        ///     ArrayList repsenting starting coordinates of all columns
+        /// </param>
+        private static int CalculateColumnSpan(int columnIndex, double columnWidth, ArrayList columnStarts)
+        {
+            // Current status of column width. Indicates the amount of width that has been scanned already
+            double columnSpanningValue;
+            int columnSpanningIndex;
+            int columnSpan;
+            double subColumnWidth; // Width of the smallest-grain columns in the table
+
+            Debug.Assert(columnStarts != null);
+            Debug.Assert(columnIndex < columnStarts.Count - 1);
+            Debug.Assert((double)columnStarts[columnIndex] >= 0);
+            Debug.Assert(columnWidth > 0);
+
+            columnSpanningIndex = columnIndex;
+            columnSpanningValue = 0;
+            columnSpan = 0;
+            subColumnWidth = 0;
+
+            while (columnSpanningValue < columnWidth && columnSpanningIndex < columnStarts.Count - 1)
+            {
+                subColumnWidth = (double)columnStarts[columnSpanningIndex + 1] -
+                                 (double)columnStarts[columnSpanningIndex];
+                Debug.Assert(subColumnWidth > 0);
+                columnSpanningValue += subColumnWidth;
+                columnSpanningIndex++;
+            }
+
+            // Now, we have either covered the width we needed to cover or reached the end of the table, in which
+            // case the column spans all the columns until the end
+            columnSpan = columnSpanningIndex - columnIndex;
+            Debug.Assert(columnSpan > 0);
+
+            return columnSpan;
+        }
+
+        /// <summary>
+        ///     Verifies that values in columnStart, which represent starting coordinates of all columns, are arranged
+        ///     in ascending order
+        /// </summary>
+        /// <param name="columnStarts">
+        ///     ArrayList representing starting coordinates of all columns
+        /// </param>
+        private static void VerifyColumnStartsAscendingOrder(ArrayList columnStarts)
+        {
+            Debug.Assert(columnStarts != null);
+
+            double columnStart;
+
+            columnStart = -0.01;
+
+            foreach (object t in columnStarts)
+            {
+                Debug.Assert(columnStart < (double)t);
+                columnStart = (double)t;
+            }
+        }
+
+        // .............................................................
+        //
+        // Attributes and Properties
+        //
+        // .............................................................
+
+        /// <summary>
+        ///     Analyzes local properties of Html element, converts them into Xaml equivalents, and applies them to xamlElement
+        /// </summary>
+        /// <param name="xamlElement">
+        ///     XmlElement representing Xaml element to which properties are to be applied
+        /// </param>
+        /// <param name="localProperties">
+        ///     Hashtable representing local properties of Html element that is converted into xamlElement
+        /// </param>
+        private static void ApplyLocalProperties(XmlElement xamlElement, Hashtable localProperties, bool isBlock)
+        {
+            var marginSet = false;
+            var marginTop = "0";
+            var marginBottom = "0";
+            var marginLeft = "0";
+            var marginRight = "0";
+
+            var paddingSet = false;
+            var paddingTop = "0";
+            var paddingBottom = "0";
+            var paddingLeft = "0";
+            var paddingRight = "0";
+
+            string borderColor = null;
+
+            var borderThicknessSet = false;
+            var borderThicknessTop = "0";
+            var borderThicknessBottom = "0";
+            var borderThicknessLeft = "0";
+            var borderThicknessRight = "0";
+
+            var propertyEnumerator = localProperties.GetEnumerator();
+            while (propertyEnumerator.MoveNext())
+            {
+                switch ((string)propertyEnumerator.Key)
+                {
+                    case "font-family":
+                        //  Convert from font-family value list into xaml FontFamily value
+                        xamlElement.SetAttribute(XamlFontFamily, (string)propertyEnumerator.Value);
+                        break;
+                    case "font-style":
+                        xamlElement.SetAttribute(XamlFontStyle, (string)propertyEnumerator.Value);
+                        break;
+                    case "font-variant":
+                        //  Convert from font-variant into xaml property
+                        break;
+                    case "font-weight":
+                        xamlElement.SetAttribute(XamlFontWeight, (string)propertyEnumerator.Value);
+                        break;
+                    case "font-size":
+                        //  Convert from css size into FontSize
+                        xamlElement.SetAttribute(XamlFontSize, (string)propertyEnumerator.Value);
+                        break;
+                    case "color":
+                        SetPropertyValue(xamlElement, TextElement.ForegroundProperty, (string)propertyEnumerator.Value);
+                        break;
+                    case "background-color":
+                        SetPropertyValue(xamlElement, TextElement.BackgroundProperty, (string)propertyEnumerator.Value);
+                        break;
+                    case "text-decoration-underline":
+                        if (!isBlock)
+                        {
+                            if ((string)propertyEnumerator.Value == "true")
+                            {
+                                xamlElement.SetAttribute(XamlTextDecorations, XamlTextDecorationsUnderline);
+                            }
+                        }
+                        break;
+                    case "text-decoration-none":
+                    case "text-decoration-overline":
+                    case "text-decoration-line-through":
+                    case "text-decoration-blink":
+                        //  Convert from all other text-decorations values
+                        if (!isBlock)
+                        {
+                        }
+                        break;
+                    case "text-transform":
+                        //  Convert from text-transform into xaml property
+                        break;
+
+                    case "text-indent":
+                        if (isBlock)
+                        {
+                            xamlElement.SetAttribute(XamlTextIndent, (string)propertyEnumerator.Value);
+                        }
+                        break;
+
+                    case "text-align":
+                        if (isBlock)
+                        {
+                            xamlElement.SetAttribute(XamlTextAlignment, (string)propertyEnumerator.Value);
+                        }
+                        break;
+
+                    case "width":
+                    case "height":
+                        //  Decide what to do with width and height propeties
+                        break;
+
+                    case "margin-top":
+                        marginSet = true;
+                        marginTop = (string)propertyEnumerator.Value;
+                        break;
+                    case "margin-right":
+                        marginSet = true;
+                        marginRight = (string)propertyEnumerator.Value;
+                        break;
+                    case "margin-bottom":
+                        marginSet = true;
+                        marginBottom = (string)propertyEnumerator.Value;
+                        break;
+                    case "margin-left":
+                        marginSet = true;
+                        marginLeft = (string)propertyEnumerator.Value;
+                        break;
+
+                    case "padding-top":
+                        paddingSet = true;
+                        paddingTop = (string)propertyEnumerator.Value;
+                        break;
+                    case "padding-right":
+                        paddingSet = true;
+                        paddingRight = (string)propertyEnumerator.Value;
+                        break;
+                    case "padding-bottom":
+                        paddingSet = true;
+                        paddingBottom = (string)propertyEnumerator.Value;
+                        break;
+                    case "padding-left":
+                        paddingSet = true;
+                        paddingLeft = (string)propertyEnumerator.Value;
+                        break;
+
+                    // NOTE: css names for elementary border styles have side indications in the middle (top/bottom/left/right)
+                    // In our internal notation we intentionally put them at the end - to unify processing in ParseCssRectangleProperty method
+                    case "border-color-top":
+                        borderColor = (string)propertyEnumerator.Value;
+                        break;
+                    case "border-color-right":
+                        borderColor = (string)propertyEnumerator.Value;
+                        break;
+                    case "border-color-bottom":
+                        borderColor = (string)propertyEnumerator.Value;
+                        break;
+                    case "border-color-left":
+                        borderColor = (string)propertyEnumerator.Value;
+                        break;
+                    case "border-style-top":
+                    case "border-style-right":
+                    case "border-style-bottom":
+                    case "border-style-left":
+                        //  Implement conversion from border style
+                        break;
+                    case "border-width-top":
+                        borderThicknessSet = true;
+                        borderThicknessTop = (string)propertyEnumerator.Value;
+                        break;
+                    case "border-width-right":
+                        borderThicknessSet = true;
+                        borderThicknessRight = (string)propertyEnumerator.Value;
+                        break;
+                    case "border-width-bottom":
+                        borderThicknessSet = true;
+                        borderThicknessBottom = (string)propertyEnumerator.Value;
+                        break;
+                    case "border-width-left":
+                        borderThicknessSet = true;
+                        borderThicknessLeft = (string)propertyEnumerator.Value;
+                        break;
+
+                    case "list-style-type":
+                        if (xamlElement.LocalName == XamlList)
+                        {
+                            string markerStyle;
+                            switch (((string)propertyEnumerator.Value).ToLower())
+                            {
+                                case "disc":
+                                    markerStyle = XamlListMarkerStyleDisc;
+                                    break;
+                                case "circle":
+                                    markerStyle = XamlListMarkerStyleCircle;
+                                    break;
+                                case "none":
+                                    markerStyle = XamlListMarkerStyleNone;
+                                    break;
+                                case "square":
+                                    markerStyle = XamlListMarkerStyleSquare;
+                                    break;
+                                case "box":
+                                    markerStyle = XamlListMarkerStyleBox;
+                                    break;
+                                case "lower-latin":
+                                    markerStyle = XamlListMarkerStyleLowerLatin;
+                                    break;
+                                case "upper-latin":
+                                    markerStyle = XamlListMarkerStyleUpperLatin;
+                                    break;
+                                case "lower-roman":
+                                    markerStyle = XamlListMarkerStyleLowerRoman;
+                                    break;
+                                case "upper-roman":
+                                    markerStyle = XamlListMarkerStyleUpperRoman;
+                                    break;
+                                case "decimal":
+                                    markerStyle = XamlListMarkerStyleDecimal;
+                                    break;
+                                default:
+                                    markerStyle = XamlListMarkerStyleDisc;
+                                    break;
+                            }
+                            xamlElement.SetAttribute(XamlListMarkerStyle, markerStyle);
+                        }
+                        break;
+
+                    case "float":
+                    case "clear":
+                        if (isBlock)
+                        {
+                            //  Convert float and clear properties
+                        }
+                        break;
+
+                    case "display":
+                        break;
+                }
+            }
+
+            if (isBlock)
+            {
+                if (marginSet)
+                {
+                    ComposeThicknessProperty(xamlElement, XamlMargin, marginLeft, marginRight, marginTop, marginBottom);
+                }
+
+                if (paddingSet)
+                {
+                    ComposeThicknessProperty(xamlElement, XamlPadding, paddingLeft, paddingRight, paddingTop,
+                        paddingBottom);
+                }
+
+                if (borderColor != null)
+                {
+                    //  We currently ignore possible difference in brush colors on different border sides. Use the last colored side mentioned
+                    xamlElement.SetAttribute(XamlBorderBrush, borderColor);
+                }
+
+                if (borderThicknessSet)
+                {
+                    ComposeThicknessProperty(xamlElement, XamlBorderThickness, borderThicknessLeft,
+                        borderThicknessRight,
+                        borderThicknessTop, borderThicknessBottom);
+                }
+            }
+        }
+
+        // Create syntactically optimized four-value Thickness
+        private static void ComposeThicknessProperty(XmlElement xamlElement, string propertyName, string left,
+            string right,
+            string top, string bottom)
+        {
+            // Xaml syntax:
+            // We have a reasonable interpreation for one value (all four edges), two values (horizontal, vertical),
+            // and four values (left, top, right, bottom).
+            //  switch (i) {
+            //    case 1: return new Thickness(lengths[0]);
+            //    case 2: return new Thickness(lengths[0], lengths[1], lengths[0], lengths[1]);
+            //    case 4: return new Thickness(lengths[0], lengths[1], lengths[2], lengths[3]);
+            //  }
+            string thickness;
+
+            // We do not accept negative margins
+            if (left[0] == '0' || left[0] == '-') left = "0";
+            if (right[0] == '0' || right[0] == '-') right = "0";
+            if (top[0] == '0' || top[0] == '-') top = "0";
+            if (bottom[0] == '0' || bottom[0] == '-') bottom = "0";
+
+            if (left == right && top == bottom)
+            {
+                if (left == top)
+                {
+                    thickness = left;
+                }
+                else
+                {
+                    thickness = left + "," + top;
+                }
+            }
+            else
+            {
+                thickness = left + "," + top + "," + right + "," + bottom;
+            }
+
+            //  Need safer processing for a thickness value
+            xamlElement.SetAttribute(propertyName, thickness);
+        }
+
+        private static void SetPropertyValue(XmlElement xamlElement, DependencyProperty property, string stringValue)
+        {
+            var typeConverter =
+                TypeDescriptor.GetConverter(property.PropertyType);
+            try
+            {
+                var convertedValue = typeConverter.ConvertFromInvariantString(stringValue);
+                if (convertedValue != null)
+                {
+                    xamlElement.SetAttribute(property.Name, stringValue);
+                }
+            }
+            catch (Exception)
+            {
+            }
+        }
+
+        /// <summary>
+        ///     Analyzes the tag of the htmlElement and infers its associated formatted properties.
+        ///     After that parses style attribute and adds all inline css styles.
+        ///     The resulting style attributes are collected in output parameter localProperties.
+        /// </summary>
+        /// <param name="htmlElement">
+        /// </param>
+        /// <param name="inheritedProperties">
+        ///     set of properties inherited from ancestor elements. Currently not used in the code. Reserved for the future
+        ///     development.
+        /// </param>
+        /// <param name="localProperties">
+        ///     returns all formatting properties defined by this element - implied by its tag, its attributes, or its css inline
+        ///     style
+        /// </param>
+        /// <param name="stylesheet"></param>
+        /// <param name="sourceContext"></param>
+        /// <returns>
+        ///     returns a combination of previous context with local set of properties.
+        ///     This value is not used in the current code - inntended for the future development.
+        /// </returns>
+        private static Hashtable GetElementProperties(XmlElement htmlElement, Hashtable inheritedProperties,
+            out Hashtable localProperties, CssStylesheet stylesheet, List<XmlElement> sourceContext)
+        {
+            // Start with context formatting properties
+            var currentProperties = new Hashtable();
+            var propertyEnumerator = inheritedProperties.GetEnumerator();
+            while (propertyEnumerator.MoveNext())
+            {
+                currentProperties[propertyEnumerator.Key] = propertyEnumerator.Value;
+            }
+
+            // Identify element name
+            var elementName = htmlElement.LocalName.ToLower();
+            var elementNamespace = htmlElement.NamespaceURI;
+
+            // update current formatting properties depending on element tag
+
+            localProperties = new Hashtable();
+            switch (elementName)
+            {
+                // Character formatting
+                case "i":
+                case "italic":
+                case "em":
+                    localProperties["font-style"] = "italic";
+                    break;
+                case "b":
+                case "bold":
+                case "strong":
+                case "dfn":
+                    localProperties["font-weight"] = "bold";
+                    break;
+                case "u":
+                case "underline":
+                    localProperties["text-decoration-underline"] = "true";
+                    break;
+                case "font":
+                    var attributeValue = GetAttribute(htmlElement, "face");
+                    if (attributeValue != null)
+                    {
+                        localProperties["font-family"] = attributeValue;
+                    }
+                    attributeValue = GetAttribute(htmlElement, "size");
+                    if (attributeValue != null)
+                    {
+                        var fontSize = double.Parse(attributeValue) * (12.0 / 3.0);
+                        if (fontSize < 1.0)
+                        {
+                            fontSize = 1.0;
+                        }
+                        else if (fontSize > 1000.0)
+                        {
+                            fontSize = 1000.0;
+                        }
+                        localProperties["font-size"] = fontSize.ToString(CultureInfo.InvariantCulture);
+                    }
+                    attributeValue = GetAttribute(htmlElement, "color");
+                    if (attributeValue != null)
+                    {
+                        localProperties["color"] = attributeValue;
+                    }
+                    break;
+                case "samp":
+                    localProperties["font-family"] = "Courier New"; // code sample
+                    localProperties["font-size"] = XamlFontSizeXxSmall;
+                    localProperties["text-align"] = "Left";
+                    break;
+                case "sub":
+                    break;
+                case "sup":
+                    break;
+
+                // Hyperlinks
+                case "a": // href, hreflang, urn, methods, rel, rev, title
+                    //  Set default hyperlink properties
+                    break;
+                case "acronym":
+                    break;
+
+                // Paragraph formatting:
+                case "p":
+                    //  Set default paragraph properties
+                    break;
+                case "div":
+                    //  Set default div properties
+                    break;
+                case "pre":
+                    localProperties["font-family"] = "Courier New"; // renders text in a fixed-width font
+                    localProperties["font-size"] = XamlFontSizeXxSmall;
+                    localProperties["text-align"] = "Left";
+                    break;
+                case "blockquote":
+                    localProperties["margin-left"] = "16";
+                    break;
+
+                case "h1":
+                    localProperties["font-size"] = XamlFontSizeXxLarge;
+                    break;
+                case "h2":
+                    localProperties["font-size"] = XamlFontSizeXLarge;
+                    break;
+                case "h3":
+                    localProperties["font-size"] = XamlFontSizeLarge;
+                    break;
+                case "h4":
+                    localProperties["font-size"] = XamlFontSizeMedium;
+                    break;
+                case "h5":
+                    localProperties["font-size"] = XamlFontSizeSmall;
+                    break;
+                case "h6":
+                    localProperties["font-size"] = XamlFontSizeXSmall;
+                    break;
+                // List properties
+                case "ul":
+                    localProperties["list-style-type"] = "disc";
+                    break;
+                case "ol":
+                    localProperties["list-style-type"] = "decimal";
+                    break;
+
+                case "table":
+                case "body":
+                case "html":
+                    break;
+            }
+
+            // Override html defaults by css attributes - from stylesheets and inline settings
+            HtmlCssParser.GetElementPropertiesFromCssAttributes(htmlElement, elementName, stylesheet, localProperties,
+                sourceContext);
+
+            // Combine local properties with context to create new current properties
+            propertyEnumerator = localProperties.GetEnumerator();
+            while (propertyEnumerator.MoveNext())
+            {
+                currentProperties[propertyEnumerator.Key] = propertyEnumerator.Value;
+            }
+
+            return currentProperties;
+        }
+
+        /// <summary>
+        ///     Extracts a value of css attribute from css style definition.
+        /// </summary>
+        /// <param name="cssStyle">
+        ///     Source csll style definition
+        /// </param>
+        /// <param name="attributeName">
+        ///     A name of css attribute to extract
+        /// </param>
+        /// <returns>
+        ///     A string rrepresentation of an attribute value if found;
+        ///     null if there is no such attribute in a given string.
+        /// </returns>
+        private static string GetCssAttribute(string cssStyle, string attributeName)
+        {
+            //  This is poor man's attribute parsing. Replace it by real css parsing
+            if (cssStyle != null)
+            {
+                string[] styleValues;
+
+                attributeName = attributeName.ToLower();
+
+                // Check for width specification in style string
+                styleValues = cssStyle.Split(';');
+
+                foreach (string t in styleValues)
+                {
+                    string[] styleNameValue;
+
+                    styleNameValue = t.Split(':');
+                    if (styleNameValue.Length == 2)
+                    {
+                        if (styleNameValue[0].Trim().ToLower() == attributeName)
+                        {
+                            return styleNameValue[1].Trim();
+                        }
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        ///     Converts a length value from string representation to a double.
+        /// </summary>
+        /// <param name="lengthAsString">
+        ///     Source string value of a length.
+        /// </param>
+        /// <param name="length"></param>
+        /// <returns></returns>
+        private static bool TryGetLengthValue(string lengthAsString, out double length)
+        {
+            length = double.NaN;
+
+            if (lengthAsString != null)
+            {
+                lengthAsString = lengthAsString.Trim().ToLower();
+
+                // We try to convert currentColumnWidthAsString into a double. This will eliminate widths of type "50%", etc.
+                if (lengthAsString.EndsWith("pt"))
+                {
+                    lengthAsString = lengthAsString.Substring(0, lengthAsString.Length - 2);
+                    if (double.TryParse(lengthAsString, out length))
+                    {
+                        length = (length * 96.0) / 72.0; // convert from points to pixels
+                    }
+                    else
+                    {
+                        length = double.NaN;
+                    }
+                }
+                else if (lengthAsString.EndsWith("px"))
+                {
+                    lengthAsString = lengthAsString.Substring(0, lengthAsString.Length - 2);
+                    if (!double.TryParse(lengthAsString, out length))
+                    {
+                        length = double.NaN;
+                    }
+                }
+                else
+                {
+                    if (!double.TryParse(lengthAsString, out length)) // Assuming pixels
+                    {
+                        length = double.NaN;
+                    }
+                }
+            }
+
+            return !double.IsNaN(length);
+        }
+
+        // .................................................................
+        //
+        // Pasring Color Attribute
+        //
+        // .................................................................
+
+        private static string GetColorValue(string colorValue) => colorValue;
+
+        /// <summary>
+        ///     Applies properties to xamlTableCellElement based on the html td element it is converted from.
+        /// </summary>
+        /// <param name="htmlChildNode">
+        ///     Html td/th element to be converted to xaml
+        /// </param>
+        /// <param name="xamlTableCellElement">
+        ///     XmlElement representing Xaml element for which properties are to be processed
+        /// </param>
+        /// <remarks>
+        ///     TODO: Use the processed properties for htmlChildNode instead of using the node itself
+        /// </remarks>
+        private static void ApplyPropertiesToTableCellElement(XmlElement htmlChildNode, XmlElement xamlTableCellElement)
+        {
+            // Parameter validation
+            Debug.Assert(htmlChildNode.LocalName.ToLower() == "td" || htmlChildNode.LocalName.ToLower() == "th");
+            Debug.Assert(xamlTableCellElement.LocalName == XamlTableCell);
+
+            // set default border thickness for xamlTableCellElement to enable gridlines
+            xamlTableCellElement.SetAttribute(XamlTableCellBorderThickness, "1,1,1,1");
+            xamlTableCellElement.SetAttribute(XamlTableCellBorderBrush, XamlBrushesBlack);
+            var rowSpanString = GetAttribute(htmlChildNode, "rowspan");
+            if (rowSpanString != null)
+            {
+                xamlTableCellElement.SetAttribute(XamlTableCellRowSpan, rowSpanString);
+            }
+        }
+
+        #endregion Private Methods
+    }
+}
diff --git a/MedLaunch/Classes/HtmlToXaml/HtmlTokenType.cs b/MedLaunch/Classes/HtmlToXaml/HtmlTokenType.cs
new file mode 100644
index 0000000..b5df44e
--- /dev/null
+++ b/MedLaunch/Classes/HtmlToXaml/HtmlTokenType.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MedLaunch.Classes.HtmlToXaml
+{
+    /// <summary>
+    ///     types of lexical tokens for html-to-xaml converter
+    /// </summary>
+    internal enum HtmlTokenType
+    {
+        OpeningTagStart,
+        ClosingTagStart,
+        TagEnd,
+        EmptyTagEnd,
+        EqualSign,
+        Name,
+        Atom, // any attribute value not in quotes
+        Text, //text content when accepting text
+        Comment,
+        Eof
+    }
+}
diff --git a/MedLaunch/Classes/VisualHandlers/ConfigsVisualHandler.cs b/MedLaunch/Classes/VisualHandlers/ConfigsVisualHandler.cs
index d8374f1..18dc2eb 100644
--- a/MedLaunch/Classes/VisualHandlers/ConfigsVisualHandler.cs
+++ b/MedLaunch/Classes/VisualHandlers/ConfigsVisualHandler.cs
@@ -119,7 +119,7 @@ public static void HideControls(WrapPanel wp, int configId)
             UIHandler ui = UIHandler.GetChildren(wp);
 
             ConfigsVisualHandler cv = new ConfigsVisualHandler();
-            Border b = (Border)cv.MWindow.FindName("brdNONDYNAMICvfilters");
+            //Border b = (Border)cv.MWindow.FindName("brdNONDYNAMICvfilters");
 
             // get a list of system codes
             List<string> codes = (from a in GSystem.GetSystems()
@@ -128,7 +128,7 @@ public static void HideControls(WrapPanel wp, int configId)
             // iterate through each ui element and collapse the ones that are not needed for system specific settings
             if (configId != 2000000000)
             {
-                b.Visibility = Visibility.Collapsed;
+                //b.Visibility = Visibility.Collapsed;
                 foreach (Button x in ui.Buttons)
                 {
                     if (x.Name.StartsWith("cfg___"))
@@ -191,11 +191,11 @@ public static void HideControls(WrapPanel wp, int configId)
                 GlobalSettings gs = GlobalSettings.GetGlobals();
                 if (gs.showAllBaseSettings == true)
                 {
-                    b.Visibility = Visibility.Collapsed;
+                    //b.Visibility = Visibility.Collapsed;
                 }
                 else
                 {
-                    b.Visibility = Visibility.Visible;
+                    //b.Visibility = Visibility.Visible;
                     foreach (Button x in ui.Buttons)
                     {
                         if (x.Name.StartsWith("cfg___"))
diff --git a/MedLaunch/Data/System/ToolTips.json b/MedLaunch/Data/System/ToolTips.json
new file mode 100644
index 0000000..4ea5c2b
--- /dev/null
+++ b/MedLaunch/Data/System/ToolTips.json
@@ -0,0 +1,2318 @@
+[
+  {
+    "Command": "lynx.lowpass",
+    "Description": "Enable sound output lowpass filter."
+  },
+  {
+    "Command": "lynx.rotateinput",
+    "Description": "Virtually rotate D-pad along with screen."
+  },
+  {
+    "Command": "lynx.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "lynx.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "lynx.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "lynx.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "lynx.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "lynx.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "lynx.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "lynx.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "lynx.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "lynx.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "lynx.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "lynx.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "lynx.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "lynx.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "lynx.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "lynx.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "gb.system_type",
+    "Description": "Emulated GB type.\n\n<b>auto</b> - Auto\nAutomatic detection based on headers.\n\n<b>dmg</b> - DMG\nOriginal GameBoy Monochrome.\n\n<b>cgb</b> - CGB\nGameBoy Color.\n\n\n\nThis option is not fully implemented in regards to handling of DMG games.\n\n<b>agb</b> - AGB\nGameBoy Advance.\n\n\n\nThis option is not fully implemented in regards to handling of DMG games."
+  },
+  {
+    "Command": "gb.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "gb.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "gb.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "gb.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "gb.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "gb.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "gb.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "gb.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "gb.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "gb.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "gb.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "gb.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "gb.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "gb.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "gb.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "gb.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "gba.bios",
+    "Description": "Path to optional GBA BIOS ROM image."
+  },
+  {
+    "Command": "gba.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "gba.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "gba.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "gba.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "gba.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "gba.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "gba.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "gba.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "gba.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "gba.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "gba.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "gba.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "gba.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "gba.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "gba.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "gba.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "ngp.language",
+    "Description": "Language games should display text in.\n\n<b>japanese</b> - Japanese\n\n\n<b>english</b> - English\n"
+  },
+  {
+    "Command": "ngp.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "ngp.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "ngp.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "ngp.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "ngp.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "ngp.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "ngp.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "ngp.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "ngp.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "ngp.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "ngp.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "ngp.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "ngp.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "ngp.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "ngp.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "ngp.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "nes.clipsides",
+    "Description": "Clip left+right 8 pixel columns."
+  },
+  {
+    "Command": "nes.correct_aspect",
+    "Description": "Correct the aspect ratio."
+  },
+  {
+    "Command": "nes.fnscan",
+    "Description": "Scan filename for (U),(J),(E),etc. strings to en/dis-able PAL emulation.\n\nWarning: This option may break NES network play when enabled IF the players are using ROM images with different filenames."
+  },
+  {
+    "Command": "nes.gg",
+    "Description": "Enable Game Genie emulation."
+  },
+  {
+    "Command": "nes.ggrom",
+    "Description": "Path to Game Genie ROM image."
+  },
+  {
+    "Command": "nes.input.fcexp",
+    "Description": "Input device for Famicom Expansion Port\n\n<b>none</b> - none\n\n\n<b>arkanoid</b> - Arkanoid Paddle\n\n\n<b>shadow</b> - Space Shadow Gun\n\n\n<b>4player</b> - 4-player Adapter\n\n\n<b>fkb</b> - Family Keyboard\n\n\n<b>hypershot</b> - Hypershot Paddles\n\n\n<b>mahjong</b> - Mahjong Controller\n\n\n<b>partytap</b> - Party Tap\n\n\n<b>ftrainera</b> - Family Trainer Side A\n\n\n<b>ftrainerb</b> - Family Trainer Side B\n\n\n<b>oekakids</b> - Oeka Kids Tablet\n\n\n<b>bworld</b> - Barcode World Scanner\n"
+  },
+  {
+    "Command": "nes.input.port1",
+    "Description": "Input device for Port 1\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>zapper</b> - Zapper\n\n\n<b>powerpada</b> - Power Pad Side A\n\n\n<b>powerpadb</b> - Power Pad Side B\n\n\n<b>arkanoid</b> - Arkanoid Paddle\n"
+  },
+  {
+    "Command": "nes.input.port2",
+    "Description": "Input device for Port 2\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>zapper</b> - Zapper\n\n\n<b>powerpada</b> - Power Pad Side A\n\n\n<b>powerpadb</b> - Power Pad Side B\n\n\n<b>arkanoid</b> - Arkanoid Paddle\n"
+  },
+  {
+    "Command": "nes.input.port3",
+    "Description": "Input device for Port 3\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n"
+  },
+  {
+    "Command": "nes.input.port4",
+    "Description": "Input device for Port 4\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n"
+  },
+  {
+    "Command": "nes.n106bs",
+    "Description": "Enable less-accurate, but better sounding, Namco 106(mapper 19) sound emulation."
+  },
+  {
+    "Command": "nes.no8lim",
+    "Description": "Remove 8-sprites-per-scanline hardware limit.\n\nWARNING: Enabling this option will cause graphical glitches in some games, including \"Solstice\"."
+  },
+  {
+    "Command": "nes.nofs",
+    "Description": "Disable four-score emulation."
+  },
+  {
+    "Command": "nes.ntsc.brightness",
+    "Description": "NTSC composite blitter brightness."
+  },
+  {
+    "Command": "nes.ntsc.contrast",
+    "Description": "NTSC composite blitter contrast."
+  },
+  {
+    "Command": "nes.ntsc.hue",
+    "Description": "NTSC composite blitter hue."
+  },
+  {
+    "Command": "nes.ntsc.matrix",
+    "Description": "Enable NTSC custom decoder matrix."
+  },
+  {
+    "Command": "nes.ntsc.matrix.0",
+    "Description": "NTSC custom decoder matrix element 0(red, value * V)."
+  },
+  {
+    "Command": "nes.ntsc.matrix.1",
+    "Description": "NTSC custom decoder matrix element 1(red, value * U)."
+  },
+  {
+    "Command": "nes.ntsc.matrix.2",
+    "Description": "NTSC custom decoder matrix element 2(green, value * V)."
+  },
+  {
+    "Command": "nes.ntsc.matrix.3",
+    "Description": "NTSC custom decoder matrix element 3(green, value * U)."
+  },
+  {
+    "Command": "nes.ntsc.matrix.4",
+    "Description": "NTSC custom decoder matrix element 4(blue, value * V)."
+  },
+  {
+    "Command": "nes.ntsc.matrix.5",
+    "Description": "NTSC custom decoder matrix element 5(blue, value * U."
+  },
+  {
+    "Command": "nes.ntsc.mergefields",
+    "Description": "Merge fields to partially work around !=60.1Hz refresh rates."
+  },
+  {
+    "Command": "nes.ntsc.preset",
+    "Description": "Video quality/type preset.\n\n<b>disabled</b> - Disabled\n\n\n<b>composite</b> - Composite Video\n\n\n<b>svideo</b> - S-Video\n\n\n<b>rgb</b> - RGB\n\n\n<b>monochrome</b> - Monochrome\n"
+  },
+  {
+    "Command": "nes.ntsc.saturation",
+    "Description": "NTSC composite blitter saturation."
+  },
+  {
+    "Command": "nes.ntsc.sharpness",
+    "Description": "NTSC composite blitter sharpness."
+  },
+  {
+    "Command": "nes.ntscblitter",
+    "Description": "Enable NTSC color generation and blitter.\n\nNOTE: If your refresh rate isn't very close to 60.1Hz(+-0.1), you will need to set the nes.ntsc.mergefields setting to \"1\" to avoid excessive flickering."
+  },
+  {
+    "Command": "nes.pal",
+    "Description": "Enable PAL(50Hz) NES emulation."
+  },
+  {
+    "Command": "nes.slend",
+    "Description": "Last displayed scanline in NTSC mode."
+  },
+  {
+    "Command": "nes.slendp",
+    "Description": "Last displayed scanline in PAL mode."
+  },
+  {
+    "Command": "nes.slstart",
+    "Description": "First displayed scanline in NTSC mode."
+  },
+  {
+    "Command": "nes.slstartp",
+    "Description": "First displayed scanline in PAL mode."
+  },
+  {
+    "Command": "nes.sound_rate_error",
+    "Description": "Output rate tolerance.\n\nLower values correspond to better matching of the output rate of the resampler to the actual desired output rate, at the expense of increased RAM usage and poorer CPU cache utilization.  DO NOT INCREASE THIS VALUE, OR SOUND WILL LIKELY BE OFF-KEY AND THE WRONG TEMPO, AMONG OTHER PROBLEMS."
+  },
+  {
+    "Command": "nes.soundq",
+    "Description": "Sound quality.\n\nHigher values correspond to better SNR and better preservation of higher frequencies(\"brightness\"), at the cost of increased computational complexity and a negligible(<0.5ms) increase=\"\" in=\"\"></0.5ms)"
+  },
+  {
+    "Command": "nes.debugger.disfontsize",
+    "Description": "Disassembly font size.\n\nNote: Setting the font size to larger than the default may cause text overlap in the debugger.>\n\n<b>5x7</b> - 5x7\n\n\n<b>6x9</b> - 6x9\n\n\n<b>6x12</b> - 6x12\n\n\n<b>6x13</b> - 6x13.  CJK support.\n\n\n<b>9x18</b> - 9x18;  CJK support.\n"
+  },
+  {
+    "Command": "nes.debugger.memcharenc",
+    "Description": "Character encoding for the debugger's memory editor."
+  },
+  {
+    "Command": "nes.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "nes.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "nes.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "nes.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "nes.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "nes.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "nes.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "nes.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "nes.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "nes.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "nes.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "nes.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "nes.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "nes.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "nes.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "pce_fast.adpcmlp",
+    "Description": "Enable dynamic ADPCM lowpass filter."
+  },
+  {
+    "Command": "pce_fast.adpcmvolume",
+    "Description": "ADPCM volume."
+  },
+  {
+    "Command": "pce_fast.arcadecard",
+    "Description": "Enable Arcade Card emulation."
+  },
+  {
+    "Command": "pce_fast.cdbios",
+    "Description": "Path to the CD BIOS"
+  },
+  {
+    "Command": "pce_fast.cddavolume",
+    "Description": "CD-DA volume."
+  },
+  {
+    "Command": "pce_fast.cdpsgvolume",
+    "Description": "PSG volume when playing a CD game."
+  },
+  {
+    "Command": "pce_fast.cdspeed",
+    "Description": "CD-ROM data transfer speed multiplier."
+  },
+  {
+    "Command": "pce_fast.correct_aspect",
+    "Description": "Correct the aspect ratio."
+  },
+  {
+    "Command": "pce_fast.disable_softreset",
+    "Description": "If set, when RUN+SEL are pressed simultaneously, disable both buttons temporarily."
+  },
+  {
+    "Command": "pce_fast.forcesgx",
+    "Description": "Force SuperGrafx emulation."
+  },
+  {
+    "Command": "pce_fast.input.port1",
+    "Description": "Input device for Port 1\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n"
+  },
+  {
+    "Command": "pce_fast.input.port2",
+    "Description": "Input device for Port 2\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n"
+  },
+  {
+    "Command": "pce_fast.input.port3",
+    "Description": "Input device for Port 3\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n"
+  },
+  {
+    "Command": "pce_fast.input.port4",
+    "Description": "Input device for Port 4\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n"
+  },
+  {
+    "Command": "pce_fast.input.port5",
+    "Description": "Input device for Port 5\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n"
+  },
+  {
+    "Command": "pce_fast.mouse_sensitivity",
+    "Description": "Mouse sensitivity."
+  },
+  {
+    "Command": "pce_fast.nospritelimit",
+    "Description": "Remove 16-sprites-per-scanline hardware limit."
+  },
+  {
+    "Command": "pce_fast.ocmultiplier",
+    "Description": "CPU overclock multiplier."
+  },
+  {
+    "Command": "pce_fast.slend",
+    "Description": "Last rendered scanline."
+  },
+  {
+    "Command": "pce_fast.slstart",
+    "Description": "First rendered scanline."
+  },
+  {
+    "Command": "pce_fast.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "pce_fast.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "pce_fast.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "pce_fast.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "pce_fast.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "pce_fast.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "pce_fast.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "pce_fast.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "pce_fast.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "pce_fast.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "pce_fast.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "pce_fast.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "pce_fast.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "pce_fast.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "pce_fast.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "pce_fast.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "pce.adpcmextraprec",
+    "Description": "Output the full 12-bit ADPCM predictor.\n\nEnabling this option causes the MSM5205 ADPCM predictor to be outputted with full precision of 12-bits, rather than only outputting 10-bits of precision(as an actual MSM5205 does).  Enable this option to reduce whining noise during ADPCM playback."
+  },
+  {
+    "Command": "pce.adpcmvolume",
+    "Description": "ADPCM volume.\n\nSetting this volume control too high may cause sample clipping."
+  },
+  {
+    "Command": "pce.arcadecard",
+    "Description": "Enable Arcade Card emulation.\n\nLeaving this option enabled is recommended, unless you want to see special warning screens on ACD games, or you prefer the non-enhanced modes of ACD-enhanced SCD games.  Additionally, you may want to disable it you you wish to use state rewinding with a SCD ACD-enhanced game on a slow CPU, as the extra 2MiB of RAM the Arcade Card offers is difficult to compress in real-time."
+  },
+  {
+    "Command": "pce.cdbios",
+    "Description": "Path to the CD BIOS"
+  },
+  {
+    "Command": "pce.cddavolume",
+    "Description": "CD-DA volume.\n\nSetting this volume control too high may cause sample clipping."
+  },
+  {
+    "Command": "pce.cdpsgvolume",
+    "Description": "PSG volume when playing a CD game.\n\nSetting this volume control too high may cause sample clipping."
+  },
+  {
+    "Command": "pce.disable_bram_cd",
+    "Description": "Disable BRAM(saved game memory) for CD games.\n\nIt is intended for viewing CD games' error screens that may be different from simple BRAM full and uninitialized BRAM error screens, though it can cause the game to crash outright."
+  },
+  {
+    "Command": "pce.disable_bram_hucard",
+    "Description": "Disable BRAM(saved game memory) for HuCard games.\n\nIt is intended for changing the behavior(passwords vs save games) of some HuCard games."
+  },
+  {
+    "Command": "pce.disable_softreset",
+    "Description": "If set, when RUN+SEL are pressed simultaneously, disable both buttons temporarily."
+  },
+  {
+    "Command": "pce.forcesgx",
+    "Description": "Force SuperGrafx emulation.\n\nEnabling this option is not necessary to run unrecognized PCE ROM images in SuperGrafx mode, and enabling it is discouraged; ROM images with a file extension of \".sgx\" will automatically enable SuperGrafx emulation."
+  },
+  {
+    "Command": "pce.gecdbios",
+    "Description": "Path to the GE CD BIOS\n\nGames Express CD Card BIOS (Unlicensed)"
+  },
+  {
+    "Command": "pce.h_overscan",
+    "Description": "Show horizontal overscan area."
+  },
+  {
+    "Command": "pce.input.multitap",
+    "Description": "Enable multitap(TurboTap) emulation."
+  },
+  {
+    "Command": "pce.input.port1",
+    "Description": "Input device for Port 1\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n\n\n<b>tsushinkb</b> - Tsushin Keyboard\n"
+  },
+  {
+    "Command": "pce.input.port2",
+    "Description": "Input device for Port 2\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n"
+  },
+  {
+    "Command": "pce.input.port3",
+    "Description": "Input device for Port 3\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n"
+  },
+  {
+    "Command": "pce.input.port4",
+    "Description": "Input device for Port 4\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n"
+  },
+  {
+    "Command": "pce.input.port5",
+    "Description": "Input device for Port 5\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n"
+  },
+  {
+    "Command": "pce.mouse_sensitivity",
+    "Description": "Emulated mouse sensitivity."
+  },
+  {
+    "Command": "pce.nospritelimit",
+    "Description": "Remove 16-sprites-per-scanline hardware limit.\n\nWARNING: Enabling this option may cause undesirable graphics glitching on some games(such as \"Bloody Wolf\")."
+  },
+  {
+    "Command": "pce.psgrevision",
+    "Description": "Select PSG revision.\n\nWARNING: HES playback will always use the \"huc6280a\" revision if this setting is set to \"match\", since HES playback is always done with SuperGrafx emulation enabled.>\n\n<b>huc6280</b> - HuC6280\nHuC6280 as found in the original PC Engine.\n\n<b>huc6280a</b> - HuC6280A\nHuC6280A as found in the SuperGrafx and CoreGrafx I.  Provides proper channel amplitude centering, but may cause clicking in a few games designed with the original HuC6280's sound characteristics in mind.\n\n<b>match</b> - Match emulation mode.\nSelects \"huc6280\" for non-SuperGrafx mode, and \"huc6280a\" for SuperGrafx(full) mode."
+  },
+  {
+    "Command": "pce.resamp_quality",
+    "Description": "Sound quality.\n\nHigher values correspond to better SNR and better preservation of higher frequencies(\"brightness\"), at the cost of increased computational complexity and a negligible increase in latency.\n\n\n\nHigher values will also slightly increase the probability of sample clipping(relevant if Mednafen's volume control settings are set too high), due to increased (time-domain) ringing."
+  },
+  {
+    "Command": "pce.resamp_rate_error",
+    "Description": "Sound output rate tolerance.\n\nLower values correspond to better matching of the output rate of the resampler to the actual desired output rate, at the expense of increased RAM usage and poorer CPU cache utilization."
+  },
+  {
+    "Command": "pce.slend",
+    "Description": "Last rendered scanline."
+  },
+  {
+    "Command": "pce.slstart",
+    "Description": "First rendered scanline."
+  },
+  {
+    "Command": "pce.debugger.disfontsize",
+    "Description": "Disassembly font size.\n\nNote: Setting the font size to larger than the default may cause text overlap in the debugger.>\n\n<b>5x7</b> - 5x7\n\n\n<b>6x9</b> - 6x9\n\n\n<b>6x12</b> - 6x12\n\n\n<b>6x13</b> - 6x13.  CJK support.\n\n\n<b>9x18</b> - 9x18;  CJK support.\n"
+  },
+  {
+    "Command": "pce.debugger.memcharenc",
+    "Description": "Character encoding for the debugger's memory editor."
+  },
+  {
+    "Command": "pce.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "pce.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "pce.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "pce.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "pce.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "pce.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "pce.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "pce.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "pce.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "pce.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "pce.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "pce.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "pce.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "pce.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "pce.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "pce.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "gg.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "gg.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "gg.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "gg.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "gg.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "gg.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "gg.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "gg.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "gg.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "gg.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "gg.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "gg.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "gg.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "gg.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "gg.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "gg.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "md.cdbios",
+    "Description": "Path to the CD BIOS\n\nSegaCD/MegaCD emulation is currently nonfunctional."
+  },
+  {
+    "Command": "md.correct_aspect",
+    "Description": "Correct the aspect ratio."
+  },
+  {
+    "Command": "md.input.auto",
+    "Description": "Automatically select appropriate input devices.\n\nAutomatically select appropriate input devices, based on an internal database.  Currently, only multitap device usage data is contained in the database."
+  },
+  {
+    "Command": "md.input.mouse_sensitivity",
+    "Description": "Emulated mouse sensitivity."
+  },
+  {
+    "Command": "md.input.multitap",
+    "Description": "Enable multitap(s).\n\n<b>none</b> - No multitap(s).\n\n\n<b>tp1</b> - Team Player/Sega Tap on MD/Genesis port 1.\n\n\n<b>tp2</b> - Team Player/Sega Tap on MD/Genesis port 2.\n\n\n<b>tpd</b> - Team Player/Sega Tap on both MD/Genesis ports.\n\n\n<b>4way</b> - EA 4-Way Play\n"
+  },
+  {
+    "Command": "md.input.port1",
+    "Description": "Input device for Virtual Port 1\n\n<b>none</b> - none\n\n\n<b>gamepad2</b> - 2-Button Gamepad\n\n\n<b>gamepad</b> - 3-Button Gamepad\n\n\n<b>gamepad6</b> - 6-Button Gamepad\n\n\n<b>megamouse</b> - Sega Mega Mouse\n"
+  },
+  {
+    "Command": "md.input.port2",
+    "Description": "Input device for Virtual Port 2\n\n<b>none</b> - none\n\n\n<b>gamepad2</b> - 2-Button Gamepad\n\n\n<b>gamepad</b> - 3-Button Gamepad\n\n\n<b>gamepad6</b> - 6-Button Gamepad\n\n\n<b>megamouse</b> - Sega Mega Mouse\n"
+  },
+  {
+    "Command": "md.input.port3",
+    "Description": "Input device for Virtual Port 3\n\n<b>none</b> - none\n\n\n<b>gamepad2</b> - 2-Button Gamepad\n\n\n<b>gamepad</b> - 3-Button Gamepad\n\n\n<b>gamepad6</b> - 6-Button Gamepad\n\n\n<b>megamouse</b> - Sega Mega Mouse\n"
+  },
+  {
+    "Command": "md.input.port4",
+    "Description": "Input device for Virtual Port 4\n\n<b>none</b> - none\n\n\n<b>gamepad2</b> - 2-Button Gamepad\n\n\n<b>gamepad</b> - 3-Button Gamepad\n\n\n<b>gamepad6</b> - 6-Button Gamepad\n\n\n<b>megamouse</b> - Sega Mega Mouse\n"
+  },
+  {
+    "Command": "md.input.port5",
+    "Description": "Input device for Virtual Port 5\n\n<b>none</b> - none\n\n\n<b>gamepad2</b> - 2-Button Gamepad\n\n\n<b>gamepad</b> - 3-Button Gamepad\n\n\n<b>gamepad6</b> - 6-Button Gamepad\n\n\n<b>megamouse</b> - Sega Mega Mouse\n"
+  },
+  {
+    "Command": "md.input.port6",
+    "Description": "Input device for Virtual Port 6\n\n<b>none</b> - none\n\n\n<b>gamepad2</b> - 2-Button Gamepad\n\n\n<b>gamepad</b> - 3-Button Gamepad\n\n\n<b>gamepad6</b> - 6-Button Gamepad\n\n\n<b>megamouse</b> - Sega Mega Mouse\n"
+  },
+  {
+    "Command": "md.input.port7",
+    "Description": "Input device for Virtual Port 7\n\n<b>none</b> - none\n\n\n<b>gamepad2</b> - 2-Button Gamepad\n\n\n<b>gamepad</b> - 3-Button Gamepad\n\n\n<b>gamepad6</b> - 6-Button Gamepad\n\n\n<b>megamouse</b> - Sega Mega Mouse\n"
+  },
+  {
+    "Command": "md.input.port8",
+    "Description": "Input device for Virtual Port 8\n\n<b>none</b> - none\n\n\n<b>gamepad2</b> - 2-Button Gamepad\n\n\n<b>gamepad</b> - 3-Button Gamepad\n\n\n<b>gamepad6</b> - 6-Button Gamepad\n\n\n<b>megamouse</b> - Sega Mega Mouse\n"
+  },
+  {
+    "Command": "md.region",
+    "Description": "Emulate the specified region's Genesis/MegaDrive\n\n<b>game</b> - Match game's header.\nEmulate the region that the game indicates it expects to run in via data in the header(or in an internal database for a few games that may have bad header data).\n\n<b>overseas_ntsc</b> - Overseas(non-Japan), NTSC\nRegion used in North America.\n\n<b>overseas_pal</b> - Overseas(non-Japan), PAL\nRegion used in Europe.\n\n<b>domestic_ntsc</b> - Domestic(Japan), NTSC\nRegion used in Japan.\n\n<b>domestic_pal</b> - Domestic(Japan), PAL\nProbably an invalid region, but available for testing purposes anyway."
+  },
+  {
+    "Command": "md.reported_region",
+    "Description": "Region reported to the game.\n\n<b>same</b> - Match the region emulated.\n\n\n<b>game</b> - Match game's header.\nThis option, in conjunction with the \"md.region\" setting, can be used to run all games at NTSC speeds, or all games at PAL speeds.\n\n<b>overseas_ntsc</b> - Overseas(non-Japan), NTSC\nRegion used in North America.\n\n<b>overseas_pal</b> - Overseas(non-Japan), PAL\nRegion used in Europe.\n\n<b>domestic_ntsc</b> - Domestic(Japan), NTSC\nRegion used in Japan.\n\n<b>domestic_pal</b> - Domestic(Japan), PAL\nProbably an invalid region, but available for testing purposes anyway."
+  },
+  {
+    "Command": "md.debugger.disfontsize",
+    "Description": "Disassembly font size.\n\nNote: Setting the font size to larger than the default may cause text overlap in the debugger.>\n\n<b>5x7</b> - 5x7\n\n\n<b>6x9</b> - 6x9\n\n\n<b>6x12</b> - 6x12\n\n\n<b>6x13</b> - 6x13.  CJK support.\n\n\n<b>9x18</b> - 9x18;  CJK support.\n"
+  },
+  {
+    "Command": "md.debugger.memcharenc",
+    "Description": "Character encoding for the debugger's memory editor."
+  },
+  {
+    "Command": "md.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "md.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "md.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "md.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "md.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "md.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "md.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "md.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "md.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "md.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "md.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "md.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "md.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "md.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "md.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "md.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "sms.fm",
+    "Description": "Enable FM sound emulation when playing domestic/Japan-region games."
+  },
+  {
+    "Command": "sms.territory",
+    "Description": "System territory/region.\n\n<b>domestic</b> - Domestic(Japanese)\n\n\n<b>export</b> - Export(World)\n"
+  },
+  {
+    "Command": "sms.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "sms.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "sms.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "sms.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "sms.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "sms.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "sms.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "sms.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "sms.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "sms.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "sms.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "sms.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "sms.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "sms.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "sms.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "sms.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "ss.bios_jp",
+    "Description": "Path to the Japan ROM BIOS"
+  },
+  {
+    "Command": "ss.bios_na_eu",
+    "Description": "Path to the North America and Europe ROM BIOS"
+  },
+  {
+    "Command": "ss.bios_sanity",
+    "Description": "Enable BIOS ROM image sanity checks."
+  },
+  {
+    "Command": "ss.cart",
+    "Description": "Expansion cart.\n\n<b>auto</b> - Automatic\n\n\n<b>none</b> - None\n\n\n<b>backup</b> - Backup Memory(512KiB)\n\n\n<b>extram1</b> - 1MiB Extended RAM\n\n\n<b>extram4</b> - 4MiB Extended RAM\n"
+  },
+  {
+    "Command": "ss.cart.kof95_path",
+    "Description": "Path to KoF 95 ROM image."
+  },
+  {
+    "Command": "ss.cart.ultraman_path",
+    "Description": "Path to Ultraman ROM image."
+  },
+  {
+    "Command": "ss.cd_sanity",
+    "Description": "Enable CD (image) sanity checks."
+  },
+  {
+    "Command": "ss.input.mouse_sensitivity",
+    "Description": "Emulated mouse sensitivity."
+  },
+  {
+    "Command": "ss.input.port1",
+    "Description": "Input device for Virtual Port 1\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.input.port10",
+    "Description": "Input device for Virtual Port 10\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.input.port11",
+    "Description": "Input device for Virtual Port 11\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.input.port12",
+    "Description": "Input device for Virtual Port 12\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.input.port2",
+    "Description": "Input device for Virtual Port 2\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.input.port3",
+    "Description": "Input device for Virtual Port 3\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.input.port4",
+    "Description": "Input device for Virtual Port 4\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.input.port5",
+    "Description": "Input device for Virtual Port 5\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.input.port6",
+    "Description": "Input device for Virtual Port 6\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.input.port7",
+    "Description": "Input device for Virtual Port 7\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.input.port8",
+    "Description": "Input device for Virtual Port 8\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.input.port9",
+    "Description": "Input device for Virtual Port 9\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nStandard Saturn digital gamepad.\n\n<b>3dpad</b> - 3D Control Pad\n3D Control Pad\n\n<b>mouse</b> - Mouse\nMouse"
+  },
+  {
+    "Command": "ss.midsync",
+    "Description": "Enable mid-frame synchronization.\n\nMid-frame synchronization can reduce input latency, but it will increase CPU requirements."
+  },
+  {
+    "Command": "ss.region_autodetect",
+    "Description": "Attempt to auto-detect region of game."
+  },
+  {
+    "Command": "ss.region_default",
+    "Description": "Default region to use.\n\nUsed if region autodetection fails or is disabled.>\n\n<b>jp</b> - Japan\n\n\n<b>na</b> - North America\n\n\n<b>eu</b> - Europe\n\n\n<b>kr</b> - South Korea\n\n\n<b>tw</b> - Taiwan\n\n\n<b>as</b> - China\n\n\n<b>br</b> - Brazil\n\n\n<b>la</b> - Latin America\n"
+  },
+  {
+    "Command": "ss.scsp.resamp_quality",
+    "Description": "SCSP output resampler quality.\n\n0 is lowest quality and CPU usage, 10 is highest quality and CPU usage.  The resampler that this setting refers to is used for converting from 44.1KHz to the sampling rate of the host audio device Mednafen is using.  Changing Mednafen's output rate, via the \"sound.rate\" setting, to \"44100\" may bypass the resampler, which can decrease CPU usage by Mednafen, and can increase or decrease audio quality, depending on various operating system and hardware factors."
+  },
+  {
+    "Command": "ss.slend",
+    "Description": "Last displayed scanline in NTSC mode."
+  },
+  {
+    "Command": "ss.slendp",
+    "Description": "Last displayed scanline in PAL mode."
+  },
+  {
+    "Command": "ss.slstart",
+    "Description": "First displayed scanline in NTSC mode."
+  },
+  {
+    "Command": "ss.slstartp",
+    "Description": "First displayed scanline in PAL mode."
+  },
+  {
+    "Command": "ss.smpc.autortc",
+    "Description": "Automatically set RTC on game load.\n\nAutomatically set the SMPC's emulated Real-Time Clock to the host system's current time and date upon game load."
+  },
+  {
+    "Command": "ss.smpc.autortc.lang",
+    "Description": "BIOS language.\n\nAlso affects language used in some games(e.g. the European release of \"Panzer Dragoon\").>\n\n<b>english</b> - English\n\n\n<b>german</b> - Deutsch\n\n\n<b>french</b> - Français\n\n\n<b>spanish</b> - Español\n\n\n<b>italian</b> - Italiano\n\n\n<b>japanese</b> - 日本語\n"
+  },
+  {
+    "Command": "ss.debugger.disfontsize",
+    "Description": "Disassembly font size.\n\nNote: Setting the font size to larger than the default may cause text overlap in the debugger.>\n\n<b>5x7</b> - 5x7\n\n\n<b>6x9</b> - 6x9\n\n\n<b>6x12</b> - 6x12\n\n\n<b>6x13</b> - 6x13.  CJK support.\n\n\n<b>9x18</b> - 9x18;  CJK support.\n"
+  },
+  {
+    "Command": "ss.debugger.memcharenc",
+    "Description": "Character encoding for the debugger's memory editor."
+  },
+  {
+    "Command": "ss.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "ss.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "ss.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "ss.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "ss.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "ss.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "ss.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "ss.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "ss.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "ss.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "ss.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "ss.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "ss.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "ss.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "ss.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "ss.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "psx.bios_eu",
+    "Description": "Path to the Europe SCPH-5502/v3.0E ROM BIOS\n\nSHA-256 1faaa18fa820a0225e488d9f086296b8e6c46df739666093987ff7d8fd352c09"
+  },
+  {
+    "Command": "psx.bios_jp",
+    "Description": "Path to the Japan SCPH-5500/v3.0J ROM BIOS\n\nSHA-256 9c0421858e217805f4abe18698afea8d5aa36ff0727eb8484944e00eb5e7eadb"
+  },
+  {
+    "Command": "psx.bios_na",
+    "Description": "Path to the North America SCPH-5501/v3.0A ROM BIOS\n\nSHA-256 11052b6499e466bbf0a709b1f9cb6834a9418e66680387912451e971cf8a1fef"
+  },
+  {
+    "Command": "psx.bios_sanity",
+    "Description": "Enable BIOS ROM image sanity checks."
+  },
+  {
+    "Command": "psx.cd_sanity",
+    "Description": "Enable CD (image) sanity checks.\n\nSanity checks are only performed on discs detected(via heuristics) to be PS1 discs.  The checks primarily consist of ensuring that Q subchannel data is as expected for a typical commercially-released PS1 disc."
+  },
+  {
+    "Command": "psx.dbg_level",
+    "Description": "Debug printf verbosity level."
+  },
+  {
+    "Command": "psx.h_overscan",
+    "Description": "Show horizontal overscan area."
+  },
+  {
+    "Command": "psx.input.analog_mode_ct",
+    "Description": "Enable analog mode combo-button alternate toggle.\n\nWhen enabled, instead of the configured Analog mode toggle button for the emulated DualShock, use a combination of buttons to toggle it instead.  When Select, Start, and all four shoulder buttons are held down for about 1 second, the mode will toggle."
+  },
+  {
+    "Command": "psx.input.mouse_sensitivity",
+    "Description": "Emulated mouse sensitivity."
+  },
+  {
+    "Command": "psx.input.port1",
+    "Description": "Input device for Virtual Port 1\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nPlayStation digital gamepad; SCPH-1080.\n\n<b>dualshock</b> - DualShock\nDualShock gamepad; SCPH-1200.  Emulation in Mednafen includes the analog mode toggle button.  Rumble is emulated, but currently only supported on Linux, and MS Windows via the XInput API and XInput-compatible gamepads/joysticks.  If you're having trouble getting rumble to work on Linux, see if Mednafen is printing out error messages during startup regarding /dev/input/event*, and resolve the issue(s) as necessary.\n\n<b>dualanalog</b> - Dual Analog\nDual Analog gamepad; SCPH-1180.  It is the predecessor/prototype to the more advanced DualShock.  Emulated in Mednafen as forced to analog mode, and without rumble.\n\n<b>analogjoy</b> - Analog Joystick\nFlight-game-oriented dual-joystick controller; SCPH-1110.   Emulated in Mednafen as forced to analog mode.\n\n<b>mouse</b> - Mouse\n\n\n<b>negcon</b> - neGcon\nNamco's unconventional twisty racing-game-oriented gamepad; NPC-101.\n\n<b>guncon</b> - GunCon\nNamco's light gun; NPC-103.\n\n<b>justifier</b> - Konami Justifier\nKonami's light gun; SLUH-00017.  Rumored to be wrought of the coagulated rage of all who tried to shoot The Dog.  If the game you want to play supports the \"GunCon\", you should use that instead. NOTE: Currently does not work properly when on any of ports 1B-1D and 2B-2D.\n\n<b>dancepad</b> - Dance Pad\nDingo Dingo Rodeo!"
+  },
+  {
+    "Command": "psx.input.port1.analogjoy.axis_scale",
+    "Description": "Analog axis scale coefficient for Analog Joystick on Virtual Port 1."
+  },
+  {
+    "Command": "psx.input.port1.dualanalog.axis_scale",
+    "Description": "Analog axis scale coefficient for Dual Analog on Virtual Port 1."
+  },
+  {
+    "Command": "psx.input.port1.dualshock.axis_scale",
+    "Description": "Analog axis scale coefficient for DualShock on Virtual Port 1."
+  },
+  {
+    "Command": "psx.input.port1.gun_chairs",
+    "Description": "Crosshairs color for lightgun on virtual port 1.\n\nA value of 0x1000000 disables crosshair drawing."
+  },
+  {
+    "Command": "psx.input.port1.memcard",
+    "Description": "Emulate memory card on virtual port 1."
+  },
+  {
+    "Command": "psx.input.port2",
+    "Description": "Input device for Virtual Port 2\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nPlayStation digital gamepad; SCPH-1080.\n\n<b>dualshock</b> - DualShock\nDualShock gamepad; SCPH-1200.  Emulation in Mednafen includes the analog mode toggle button.  Rumble is emulated, but currently only supported on Linux, and MS Windows via the XInput API and XInput-compatible gamepads/joysticks.  If you're having trouble getting rumble to work on Linux, see if Mednafen is printing out error messages during startup regarding /dev/input/event*, and resolve the issue(s) as necessary.\n\n<b>dualanalog</b> - Dual Analog\nDual Analog gamepad; SCPH-1180.  It is the predecessor/prototype to the more advanced DualShock.  Emulated in Mednafen as forced to analog mode, and without rumble.\n\n<b>analogjoy</b> - Analog Joystick\nFlight-game-oriented dual-joystick controller; SCPH-1110.   Emulated in Mednafen as forced to analog mode.\n\n<b>mouse</b> - Mouse\n\n\n<b>negcon</b> - neGcon\nNamco's unconventional twisty racing-game-oriented gamepad; NPC-101.\n\n<b>guncon</b> - GunCon\nNamco's light gun; NPC-103.\n\n<b>justifier</b> - Konami Justifier\nKonami's light gun; SLUH-00017.  Rumored to be wrought of the coagulated rage of all who tried to shoot The Dog.  If the game you want to play supports the \"GunCon\", you should use that instead. NOTE: Currently does not work properly when on any of ports 1B-1D and 2B-2D.\n\n<b>dancepad</b> - Dance Pad\nDingo Dingo Rodeo!"
+  },
+  {
+    "Command": "psx.input.port2.analogjoy.axis_scale",
+    "Description": "Analog axis scale coefficient for Analog Joystick on Virtual Port 2."
+  },
+  {
+    "Command": "psx.input.port2.dualanalog.axis_scale",
+    "Description": "Analog axis scale coefficient for Dual Analog on Virtual Port 2."
+  },
+  {
+    "Command": "psx.input.port2.dualshock.axis_scale",
+    "Description": "Analog axis scale coefficient for DualShock on Virtual Port 2."
+  },
+  {
+    "Command": "psx.input.port2.gun_chairs",
+    "Description": "Crosshairs color for lightgun on virtual port 2.\n\nA value of 0x1000000 disables crosshair drawing."
+  },
+  {
+    "Command": "psx.input.port2.memcard",
+    "Description": "Emulate memory card on virtual port 2."
+  },
+  {
+    "Command": "psx.input.port3",
+    "Description": "Input device for Virtual Port 3\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nPlayStation digital gamepad; SCPH-1080.\n\n<b>dualshock</b> - DualShock\nDualShock gamepad; SCPH-1200.  Emulation in Mednafen includes the analog mode toggle button.  Rumble is emulated, but currently only supported on Linux, and MS Windows via the XInput API and XInput-compatible gamepads/joysticks.  If you're having trouble getting rumble to work on Linux, see if Mednafen is printing out error messages during startup regarding /dev/input/event*, and resolve the issue(s) as necessary.\n\n<b>dualanalog</b> - Dual Analog\nDual Analog gamepad; SCPH-1180.  It is the predecessor/prototype to the more advanced DualShock.  Emulated in Mednafen as forced to analog mode, and without rumble.\n\n<b>analogjoy</b> - Analog Joystick\nFlight-game-oriented dual-joystick controller; SCPH-1110.   Emulated in Mednafen as forced to analog mode.\n\n<b>mouse</b> - Mouse\n\n\n<b>negcon</b> - neGcon\nNamco's unconventional twisty racing-game-oriented gamepad; NPC-101.\n\n<b>guncon</b> - GunCon\nNamco's light gun; NPC-103.\n\n<b>justifier</b> - Konami Justifier\nKonami's light gun; SLUH-00017.  Rumored to be wrought of the coagulated rage of all who tried to shoot The Dog.  If the game you want to play supports the \"GunCon\", you should use that instead. NOTE: Currently does not work properly when on any of ports 1B-1D and 2B-2D.\n\n<b>dancepad</b> - Dance Pad\nDingo Dingo Rodeo!"
+  },
+  {
+    "Command": "psx.input.port3.analogjoy.axis_scale",
+    "Description": "Analog axis scale coefficient for Analog Joystick on Virtual Port 3."
+  },
+  {
+    "Command": "psx.input.port3.dualanalog.axis_scale",
+    "Description": "Analog axis scale coefficient for Dual Analog on Virtual Port 3."
+  },
+  {
+    "Command": "psx.input.port3.dualshock.axis_scale",
+    "Description": "Analog axis scale coefficient for DualShock on Virtual Port 3."
+  },
+  {
+    "Command": "psx.input.port3.gun_chairs",
+    "Description": "Crosshairs color for lightgun on virtual port 3.\n\nA value of 0x1000000 disables crosshair drawing."
+  },
+  {
+    "Command": "psx.input.port3.memcard",
+    "Description": "Emulate memory card on virtual port 3."
+  },
+  {
+    "Command": "psx.input.port4",
+    "Description": "Input device for Virtual Port 4\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nPlayStation digital gamepad; SCPH-1080.\n\n<b>dualshock</b> - DualShock\nDualShock gamepad; SCPH-1200.  Emulation in Mednafen includes the analog mode toggle button.  Rumble is emulated, but currently only supported on Linux, and MS Windows via the XInput API and XInput-compatible gamepads/joysticks.  If you're having trouble getting rumble to work on Linux, see if Mednafen is printing out error messages during startup regarding /dev/input/event*, and resolve the issue(s) as necessary.\n\n<b>dualanalog</b> - Dual Analog\nDual Analog gamepad; SCPH-1180.  It is the predecessor/prototype to the more advanced DualShock.  Emulated in Mednafen as forced to analog mode, and without rumble.\n\n<b>analogjoy</b> - Analog Joystick\nFlight-game-oriented dual-joystick controller; SCPH-1110.   Emulated in Mednafen as forced to analog mode.\n\n<b>mouse</b> - Mouse\n\n\n<b>negcon</b> - neGcon\nNamco's unconventional twisty racing-game-oriented gamepad; NPC-101.\n\n<b>guncon</b> - GunCon\nNamco's light gun; NPC-103.\n\n<b>justifier</b> - Konami Justifier\nKonami's light gun; SLUH-00017.  Rumored to be wrought of the coagulated rage of all who tried to shoot The Dog.  If the game you want to play supports the \"GunCon\", you should use that instead. NOTE: Currently does not work properly when on any of ports 1B-1D and 2B-2D.\n\n<b>dancepad</b> - Dance Pad\nDingo Dingo Rodeo!"
+  },
+  {
+    "Command": "psx.input.port4.analogjoy.axis_scale",
+    "Description": "Analog axis scale coefficient for Analog Joystick on Virtual Port 4."
+  },
+  {
+    "Command": "psx.input.port4.dualanalog.axis_scale",
+    "Description": "Analog axis scale coefficient for Dual Analog on Virtual Port 4."
+  },
+  {
+    "Command": "psx.input.port4.dualshock.axis_scale",
+    "Description": "Analog axis scale coefficient for DualShock on Virtual Port 4."
+  },
+  {
+    "Command": "psx.input.port4.gun_chairs",
+    "Description": "Crosshairs color for lightgun on virtual port 4.\n\nA value of 0x1000000 disables crosshair drawing."
+  },
+  {
+    "Command": "psx.input.port4.memcard",
+    "Description": "Emulate memory card on virtual port 4."
+  },
+  {
+    "Command": "psx.input.port5",
+    "Description": "Input device for Virtual Port 5\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nPlayStation digital gamepad; SCPH-1080.\n\n<b>dualshock</b> - DualShock\nDualShock gamepad; SCPH-1200.  Emulation in Mednafen includes the analog mode toggle button.  Rumble is emulated, but currently only supported on Linux, and MS Windows via the XInput API and XInput-compatible gamepads/joysticks.  If you're having trouble getting rumble to work on Linux, see if Mednafen is printing out error messages during startup regarding /dev/input/event*, and resolve the issue(s) as necessary.\n\n<b>dualanalog</b> - Dual Analog\nDual Analog gamepad; SCPH-1180.  It is the predecessor/prototype to the more advanced DualShock.  Emulated in Mednafen as forced to analog mode, and without rumble.\n\n<b>analogjoy</b> - Analog Joystick\nFlight-game-oriented dual-joystick controller; SCPH-1110.   Emulated in Mednafen as forced to analog mode.\n\n<b>mouse</b> - Mouse\n\n\n<b>negcon</b> - neGcon\nNamco's unconventional twisty racing-game-oriented gamepad; NPC-101.\n\n<b>guncon</b> - GunCon\nNamco's light gun; NPC-103.\n\n<b>justifier</b> - Konami Justifier\nKonami's light gun; SLUH-00017.  Rumored to be wrought of the coagulated rage of all who tried to shoot The Dog.  If the game you want to play supports the \"GunCon\", you should use that instead. NOTE: Currently does not work properly when on any of ports 1B-1D and 2B-2D.\n\n<b>dancepad</b> - Dance Pad\nDingo Dingo Rodeo!"
+  },
+  {
+    "Command": "psx.input.port5.analogjoy.axis_scale",
+    "Description": "Analog axis scale coefficient for Analog Joystick on Virtual Port 5."
+  },
+  {
+    "Command": "psx.input.port5.dualanalog.axis_scale",
+    "Description": "Analog axis scale coefficient for Dual Analog on Virtual Port 5."
+  },
+  {
+    "Command": "psx.input.port5.dualshock.axis_scale",
+    "Description": "Analog axis scale coefficient for DualShock on Virtual Port 5."
+  },
+  {
+    "Command": "psx.input.port5.gun_chairs",
+    "Description": "Crosshairs color for lightgun on virtual port 5.\n\nA value of 0x1000000 disables crosshair drawing."
+  },
+  {
+    "Command": "psx.input.port5.memcard",
+    "Description": "Emulate memory card on virtual port 5."
+  },
+  {
+    "Command": "psx.input.port6",
+    "Description": "Input device for Virtual Port 6\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nPlayStation digital gamepad; SCPH-1080.\n\n<b>dualshock</b> - DualShock\nDualShock gamepad; SCPH-1200.  Emulation in Mednafen includes the analog mode toggle button.  Rumble is emulated, but currently only supported on Linux, and MS Windows via the XInput API and XInput-compatible gamepads/joysticks.  If you're having trouble getting rumble to work on Linux, see if Mednafen is printing out error messages during startup regarding /dev/input/event*, and resolve the issue(s) as necessary.\n\n<b>dualanalog</b> - Dual Analog\nDual Analog gamepad; SCPH-1180.  It is the predecessor/prototype to the more advanced DualShock.  Emulated in Mednafen as forced to analog mode, and without rumble.\n\n<b>analogjoy</b> - Analog Joystick\nFlight-game-oriented dual-joystick controller; SCPH-1110.   Emulated in Mednafen as forced to analog mode.\n\n<b>mouse</b> - Mouse\n\n\n<b>negcon</b> - neGcon\nNamco's unconventional twisty racing-game-oriented gamepad; NPC-101.\n\n<b>guncon</b> - GunCon\nNamco's light gun; NPC-103.\n\n<b>justifier</b> - Konami Justifier\nKonami's light gun; SLUH-00017.  Rumored to be wrought of the coagulated rage of all who tried to shoot The Dog.  If the game you want to play supports the \"GunCon\", you should use that instead. NOTE: Currently does not work properly when on any of ports 1B-1D and 2B-2D.\n\n<b>dancepad</b> - Dance Pad\nDingo Dingo Rodeo!"
+  },
+  {
+    "Command": "psx.input.port6.analogjoy.axis_scale",
+    "Description": "Analog axis scale coefficient for Analog Joystick on Virtual Port 6."
+  },
+  {
+    "Command": "psx.input.port6.dualanalog.axis_scale",
+    "Description": "Analog axis scale coefficient for Dual Analog on Virtual Port 6."
+  },
+  {
+    "Command": "psx.input.port6.dualshock.axis_scale",
+    "Description": "Analog axis scale coefficient for DualShock on Virtual Port 6."
+  },
+  {
+    "Command": "psx.input.port6.gun_chairs",
+    "Description": "Crosshairs color for lightgun on virtual port 6.\n\nA value of 0x1000000 disables crosshair drawing."
+  },
+  {
+    "Command": "psx.input.port6.memcard",
+    "Description": "Emulate memory card on virtual port 6."
+  },
+  {
+    "Command": "psx.input.port7",
+    "Description": "Input device for Virtual Port 7\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nPlayStation digital gamepad; SCPH-1080.\n\n<b>dualshock</b> - DualShock\nDualShock gamepad; SCPH-1200.  Emulation in Mednafen includes the analog mode toggle button.  Rumble is emulated, but currently only supported on Linux, and MS Windows via the XInput API and XInput-compatible gamepads/joysticks.  If you're having trouble getting rumble to work on Linux, see if Mednafen is printing out error messages during startup regarding /dev/input/event*, and resolve the issue(s) as necessary.\n\n<b>dualanalog</b> - Dual Analog\nDual Analog gamepad; SCPH-1180.  It is the predecessor/prototype to the more advanced DualShock.  Emulated in Mednafen as forced to analog mode, and without rumble.\n\n<b>analogjoy</b> - Analog Joystick\nFlight-game-oriented dual-joystick controller; SCPH-1110.   Emulated in Mednafen as forced to analog mode.\n\n<b>mouse</b> - Mouse\n\n\n<b>negcon</b> - neGcon\nNamco's unconventional twisty racing-game-oriented gamepad; NPC-101.\n\n<b>guncon</b> - GunCon\nNamco's light gun; NPC-103.\n\n<b>justifier</b> - Konami Justifier\nKonami's light gun; SLUH-00017.  Rumored to be wrought of the coagulated rage of all who tried to shoot The Dog.  If the game you want to play supports the \"GunCon\", you should use that instead. NOTE: Currently does not work properly when on any of ports 1B-1D and 2B-2D.\n\n<b>dancepad</b> - Dance Pad\nDingo Dingo Rodeo!"
+  },
+  {
+    "Command": "psx.input.port7.analogjoy.axis_scale",
+    "Description": "Analog axis scale coefficient for Analog Joystick on Virtual Port 7."
+  },
+  {
+    "Command": "psx.input.port7.dualanalog.axis_scale",
+    "Description": "Analog axis scale coefficient for Dual Analog on Virtual Port 7."
+  },
+  {
+    "Command": "psx.input.port7.dualshock.axis_scale",
+    "Description": "Analog axis scale coefficient for DualShock on Virtual Port 7."
+  },
+  {
+    "Command": "psx.input.port7.gun_chairs",
+    "Description": "Crosshairs color for lightgun on virtual port 7.\n\nA value of 0x1000000 disables crosshair drawing."
+  },
+  {
+    "Command": "psx.input.port7.memcard",
+    "Description": "Emulate memory card on virtual port 7."
+  },
+  {
+    "Command": "psx.input.port8",
+    "Description": "Input device for Virtual Port 8\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Digital Gamepad\nPlayStation digital gamepad; SCPH-1080.\n\n<b>dualshock</b> - DualShock\nDualShock gamepad; SCPH-1200.  Emulation in Mednafen includes the analog mode toggle button.  Rumble is emulated, but currently only supported on Linux, and MS Windows via the XInput API and XInput-compatible gamepads/joysticks.  If you're having trouble getting rumble to work on Linux, see if Mednafen is printing out error messages during startup regarding /dev/input/event*, and resolve the issue(s) as necessary.\n\n<b>dualanalog</b> - Dual Analog\nDual Analog gamepad; SCPH-1180.  It is the predecessor/prototype to the more advanced DualShock.  Emulated in Mednafen as forced to analog mode, and without rumble.\n\n<b>analogjoy</b> - Analog Joystick\nFlight-game-oriented dual-joystick controller; SCPH-1110.   Emulated in Mednafen as forced to analog mode.\n\n<b>mouse</b> - Mouse\n\n\n<b>negcon</b> - neGcon\nNamco's unconventional twisty racing-game-oriented gamepad; NPC-101.\n\n<b>guncon</b> - GunCon\nNamco's light gun; NPC-103.\n\n<b>justifier</b> - Konami Justifier\nKonami's light gun; SLUH-00017.  Rumored to be wrought of the coagulated rage of all who tried to shoot The Dog.  If the game you want to play supports the \"GunCon\", you should use that instead. NOTE: Currently does not work properly when on any of ports 1B-1D and 2B-2D.\n\n<b>dancepad</b> - Dance Pad\nDingo Dingo Rodeo!"
+  },
+  {
+    "Command": "psx.input.port8.analogjoy.axis_scale",
+    "Description": "Analog axis scale coefficient for Analog Joystick on Virtual Port 8."
+  },
+  {
+    "Command": "psx.input.port8.dualanalog.axis_scale",
+    "Description": "Analog axis scale coefficient for Dual Analog on Virtual Port 8."
+  },
+  {
+    "Command": "psx.input.port8.dualshock.axis_scale",
+    "Description": "Analog axis scale coefficient for DualShock on Virtual Port 8."
+  },
+  {
+    "Command": "psx.input.port8.gun_chairs",
+    "Description": "Crosshairs color for lightgun on virtual port 8.\n\nA value of 0x1000000 disables crosshair drawing."
+  },
+  {
+    "Command": "psx.input.port8.memcard",
+    "Description": "Emulate memory card on virtual port 8."
+  },
+  {
+    "Command": "psx.input.pport1.multitap",
+    "Description": "Enable multitap on PSX port 1.\n\nMakes 3 more virtual ports available.\n\n\n\nNOTE: Enabling multitap in games that don't fully support it may cause deleterious effects."
+  },
+  {
+    "Command": "psx.input.pport2.multitap",
+    "Description": "Enable multitap on PSX port 2.\n\nMakes 3 more virtual ports available.\n\n\n\nNOTE: Enabling multitap in games that don't fully support it may cause deleterious effects."
+  },
+  {
+    "Command": "psx.region_autodetect",
+    "Description": "Attempt to auto-detect region of game."
+  },
+  {
+    "Command": "psx.region_default",
+    "Description": "Default region to use.\n\nUsed if region autodetection fails or is disabled.>\n\n<b>jp</b> - Japan\n\n\n<b>na</b> - North America\n\n\n<b>eu</b> - Europe\n"
+  },
+  {
+    "Command": "psx.slend",
+    "Description": "Last displayed scanline in NTSC mode."
+  },
+  {
+    "Command": "psx.slendp",
+    "Description": "Last displayed scanline in PAL mode."
+  },
+  {
+    "Command": "psx.slstart",
+    "Description": "First displayed scanline in NTSC mode."
+  },
+  {
+    "Command": "psx.slstartp",
+    "Description": "First displayed scanline in PAL mode."
+  },
+  {
+    "Command": "psx.spu.resamp_quality",
+    "Description": "SPU output resampler quality.\n\n0 is lowest quality and CPU usage, 10 is highest quality and CPU usage.  The resampler that this setting refers to is used for converting from 44.1KHz to the sampling rate of the host audio device Mednafen is using.  Changing Mednafen's output rate, via the \"sound.rate\" setting, to \"44100\" may bypass the resampler, which can decrease CPU usage by Mednafen, and can increase or decrease audio quality, depending on various operating system and hardware factors."
+  },
+  {
+    "Command": "psx.debugger.disfontsize",
+    "Description": "Disassembly font size.\n\nNote: Setting the font size to larger than the default may cause text overlap in the debugger.>\n\n<b>5x7</b> - 5x7\n\n\n<b>6x9</b> - 6x9\n\n\n<b>6x12</b> - 6x12\n\n\n<b>6x13</b> - 6x13.  CJK support.\n\n\n<b>9x18</b> - 9x18;  CJK support.\n"
+  },
+  {
+    "Command": "psx.debugger.memcharenc",
+    "Description": "Character encoding for the debugger's memory editor."
+  },
+  {
+    "Command": "psx.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "psx.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "psx.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "psx.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "psx.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "psx.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "psx.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "psx.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "psx.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "psx.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "psx.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "psx.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "psx.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "psx.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "psx.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "psx.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "snes_faust.input.port1",
+    "Description": "Input device for Port 1\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n"
+  },
+  {
+    "Command": "snes_faust.input.port2",
+    "Description": "Input device for Port 2\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n"
+  },
+  {
+    "Command": "snes_faust.resamp_quality",
+    "Description": "Sound quality.\n\nHigher values correspond to better SNR and better preservation of higher frequencies(\"brightness\"), at the cost of increased computational complexity and a negligible increase in latency.\n\n\n\nHigher values will also slightly increase the probability of sample clipping(relevant if Mednafen's volume control settings are set too high), due to increased (time-domain) ringing."
+  },
+  {
+    "Command": "snes_faust.resamp_rate_error",
+    "Description": "Sound output rate tolerance.\n\nLower values correspond to better matching of the output rate of the resampler to the actual desired output rate, at the expense of increased RAM usage and poorer CPU cache utilization."
+  },
+  {
+    "Command": "snes_faust.spex",
+    "Description": "Enable 1-frame speculative execution for video output.\n\nHack to reduce input->output video latency by 1 frame.  Enabling will increase CPU usage, and may cause video glitches(such as \"jerkiness\") in some oddball games, but most commercially-released games should be fine."
+  },
+  {
+    "Command": "snes_faust.spex.sound",
+    "Description": "Enable speculative execution for sound output too.\n\nOnly has an effect when speculative-execution for video output is enabled.  Will cause minor sound glitches in some games."
+  },
+  {
+    "Command": "snes_faust.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "snes_faust.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "snes_faust.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "snes_faust.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "snes_faust.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "snes_faust.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "snes_faust.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "snes_faust.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "snes_faust.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "snes_faust.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "snes_faust.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "snes_faust.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "snes_faust.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "snes_faust.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "snes_faust.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "snes_faust.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "snes.apu.resamp_quality",
+    "Description": "APU output resampler quality.\n\n0 is lowest quality and latency and CPU usage, 10 is highest quality and latency and CPU usage.\n\n\n\nWith a Mednafen sound output rate of about 32041Hz or higher: Quality \"0\" resampler has approximately 0.125ms of latency, quality \"5\" resampler has approximately 1.25ms of latency, and quality \"10\" resampler has approximately 3.99ms of latency."
+  },
+  {
+    "Command": "snes.correct_aspect",
+    "Description": "Correct the aspect ratio.\n\nNote that regardless of this setting's value, \"512\" and \"256\" width modes will be scaled to the same dimensions for display."
+  },
+  {
+    "Command": "snes.input.port1",
+    "Description": "Input device for Port 1/1A\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n"
+  },
+  {
+    "Command": "snes.input.port1.multitap",
+    "Description": "Enable multitap on SNES port 1."
+  },
+  {
+    "Command": "snes.input.port2",
+    "Description": "Input device for Port 2/2A\n\n<b>none</b> - none\n\n\n<b>gamepad</b> - Gamepad\n\n\n<b>mouse</b> - Mouse\n\n\n<b>superscope</b> - Super Scope\nMonkey!"
+  },
+  {
+    "Command": "snes.input.port2.multitap",
+    "Description": "Enable multitap on SNES port 2."
+  },
+  {
+    "Command": "snes.mouse_sensitivity",
+    "Description": "Emulated mouse sensitivity."
+  },
+  {
+    "Command": "snes.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "snes.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "snes.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "snes.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "snes.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "snes.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "snes.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "snes.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "snes.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "snes.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "snes.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "snes.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "snes.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "snes.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "snes.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "snes.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "vb.3dmode",
+    "Description": "3D mode.\n\n<b>anaglyph</b> - Anaglyph\nUsed in conjunction with classic dual-lens-color glasses.\n\n<b>cscope</b> - CyberScope\nIntended for use with the CyberScope 3D device.\n\n<b>sidebyside</b> - Side-by-Side\nThe left-eye image is displayed on the left, and the right-eye image is displayed on the right.\n\n<b>vli</b> - Vertical Line Interlaced\nVertical lines alternate between left view and right view.\n\n<b>hli</b> - Horizontal Line Interlaced\nHorizontal lines alternate between left view and right view."
+  },
+  {
+    "Command": "vb.3dreverse",
+    "Description": "Reverse left/right 3D views."
+  },
+  {
+    "Command": "vb.allow_draw_skip",
+    "Description": "Allow draw skipping.\n\nIf vb.instant_display_hack is set to \"1\", and this setting is set to \"1\", then frame-skipping the drawing to the emulated framebuffer will be allowed.  THIS WILL CAUSE GRAPHICAL GLITCHES, AND THEORETICALLY(but unlikely) GAME CRASHES, ESPECIALLY WITH DIRECT FRAMEBUFFER DRAWING GAMES."
+  },
+  {
+    "Command": "vb.anaglyph.lcolor",
+    "Description": "Anaglyph maximum-brightness color for left view."
+  },
+  {
+    "Command": "vb.anaglyph.preset",
+    "Description": "Anaglyph preset colors.\n\n<b>disabled</b> - Disabled\nForces usage of custom anaglyph colors.\n\n<b>red_blue</b> - Red/Blue\nClassic red/blue anaglyph.\n\n<b>red_cyan</b> - Red/Cyan\nImproved quality red/cyan anaglyph.\n\n<b>red_electriccyan</b> - Red/Electric Cyan\nAlternate version of red/cyan\n\n<b>red_green</b> - Red/Green\n\n\n<b>green_magenta</b> - Green/Magenta\n\n\n<b>yellow_blue</b> - Yellow/Blue\n"
+  },
+  {
+    "Command": "vb.anaglyph.rcolor",
+    "Description": "Anaglyph maximum-brightness color for right view."
+  },
+  {
+    "Command": "vb.cpu_emulation",
+    "Description": "CPU emulation mode.\n\n<b>fast</b> - Fast Mode\nFast mode trades timing accuracy, cache emulation, and executing from hardware registers and RAM not intended for code use for performance.\n\n<b>accurate</b> - Accurate Mode\nIncreased timing accuracy, though not perfect, along with cache emulation, at the cost of decreased performance.  Additionally, even the pipeline isn't correctly and fully emulated in this mode."
+  },
+  {
+    "Command": "vb.default_color",
+    "Description": "Default maximum-brightness color to use in non-anaglyph 3D modes."
+  },
+  {
+    "Command": "vb.disable_parallax",
+    "Description": "Disable parallax for BG and OBJ rendering."
+  },
+  {
+    "Command": "vb.input.instant_read_hack",
+    "Description": "Input latency reduction hack.\n\nReduces latency in some games by 20ms by returning the current pad state, rather than latched state, on serial port data reads.  This hack may cause some homebrew software to malfunction, but it should be relatively safe for commercial official games."
+  },
+  {
+    "Command": "vb.instant_display_hack",
+    "Description": "Display latency reduction hack.\n\nReduces latency in games by displaying the framebuffer 20ms earlier.  This hack has some potential of causing graphical glitches, so it is disabled by default."
+  },
+  {
+    "Command": "vb.liprescale",
+    "Description": "Line Interlaced prescale."
+  },
+  {
+    "Command": "vb.sidebyside.separation",
+    "Description": "Number of pixels to separate L/R views by.\n\nThis setting refers to pixels before vb.xscale(fs) scaling is taken into consideration.  For example, a value of \"100\" here will result in a separation of 300 screen pixels if vb.xscale(fs) is set to \"3\"."
+  },
+  {
+    "Command": "vb.debugger.disfontsize",
+    "Description": "Disassembly font size.\n\nNote: Setting the font size to larger than the default may cause text overlap in the debugger.>\n\n<b>5x7</b> - 5x7\n\n\n<b>6x9</b> - 6x9\n\n\n<b>6x12</b> - 6x12\n\n\n<b>6x13</b> - 6x13.  CJK support.\n\n\n<b>9x18</b> - 9x18;  CJK support.\n"
+  },
+  {
+    "Command": "vb.debugger.memcharenc",
+    "Description": "Character encoding for the debugger's memory editor."
+  },
+  {
+    "Command": "vb.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "vb.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "vb.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "vb.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "vb.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "vb.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "vb.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "vb.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "vb.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "vb.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "vb.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "vb.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "vb.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "vb.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "vb.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "vb.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "wswan.bday",
+    "Description": "Birth Day"
+  },
+  {
+    "Command": "wswan.blood",
+    "Description": "Blood Type\n\n<b>a</b> - A\n\n\n<b>b</b> - B\n\n\n<b>o</b> - O\n\n\n<b>ab</b> - AB\n"
+  },
+  {
+    "Command": "wswan.bmonth",
+    "Description": "Birth Month"
+  },
+  {
+    "Command": "wswan.byear",
+    "Description": "Birth Year"
+  },
+  {
+    "Command": "wswan.language",
+    "Description": "Language games should display text in.\n\nThe only game this setting is known to affect is \"Digimon Tamers - Battle Spirit\".>\n\n<b>japanese</b> - Japanese\n\n\n<b>english</b> - English\n"
+  },
+  {
+    "Command": "wswan.name",
+    "Description": "Name"
+  },
+  {
+    "Command": "wswan.rotateinput",
+    "Description": "Virtually rotate D-pads along with screen."
+  },
+  {
+    "Command": "wswan.sex",
+    "Description": "Sex\n\n<b>male</b> - Male\n\n\n<b>female</b> - Female\n"
+  },
+  {
+    "Command": "wswan.debugger.disfontsize",
+    "Description": "Disassembly font size.\n\nNote: Setting the font size to larger than the default may cause text overlap in the debugger.>\n\n<b>5x7</b> - 5x7\n\n\n<b>6x9</b> - 6x9\n\n\n<b>6x12</b> - 6x12\n\n\n<b>6x13</b> - 6x13.  CJK support.\n\n\n<b>9x18</b> - 9x18;  CJK support.\n"
+  },
+  {
+    "Command": "wswan.debugger.memcharenc",
+    "Description": "Character encoding for the debugger's memory editor."
+  },
+  {
+    "Command": "wswan.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "wswan.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "wswan.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "wswan.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "wswan.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "wswan.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "wswan.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "wswan.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "wswan.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "wswan.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "wswan.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "wswan.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "wswan.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "wswan.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "wswan.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "wswan.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "autosave",
+    "Description": "Automatic load/save state on game load/save.\n\nAutomatically save and load save states when a game is closed or loaded, respectively."
+  },
+  {
+    "Command": "cd.image_memcache",
+    "Description": "Cache entire CD images in memory.\n\nReads the entire CD image(s) into memory at startup(which will cause a small delay).  Can help obviate emulation hiccups due to emulated CD access.  May cause more harm than good on low memory systems, systems with swap enabled, and/or when the disc images in question are on a fast SSD."
+  },
+  {
+    "Command": "cheats",
+    "Description": "Enable cheats."
+  },
+  {
+    "Command": "debugger.autostepmode",
+    "Description": "Automatically go into the debugger's step mode after a game is loaded."
+  },
+  {
+    "Command": "ffnosound",
+    "Description": "Silence sound output when fast-forwarding."
+  },
+  {
+    "Command": "ffspeed",
+    "Description": "Fast-forwarding speed multiplier."
+  },
+  {
+    "Command": "fftoggle",
+    "Description": "Treat the fast-forward button as a toggle."
+  },
+  {
+    "Command": "filesys.fname_movie",
+    "Description": "Format string for movie filename.\n\nSee <a href=\"fname_format.txt\">fname_format.txt for more information.  Edit at your own risk."
+  },
+  {
+    "Command": "filesys.fname_sav",
+    "Description": "Format string for save games filename.\n\nWARNING: %x should always be included, otherwise you run the risk of overwriting save data for games that create multiple save data files.\n\n\n\nSee <a href=\"fname_format.txt\">fname_format.txt for more information.  Edit at your own risk."
+  },
+  {
+    "Command": "filesys.fname_savbackup",
+    "Description": "Format string for save game backups filename.\n\nWARNING: %x and %p should always be included.\n\n\n\nSee <a href=\"fname_format.txt\">fname_format.txt for more information.  Edit at your own risk."
+  },
+  {
+    "Command": "filesys.fname_snap",
+    "Description": "Format string for screen snapshot filenames.\n\nWARNING: %x or %p should always be included, otherwise there will be a conflict between the numeric counter text file and the image data file.\n\n\n\nSee <a href=\"fname_format.txt\">fname_format.txt for more information.  Edit at your own risk."
+  },
+  {
+    "Command": "filesys.fname_state",
+    "Description": "Format string for state filename.\n\nSee <a href=\"fname_format.txt\">fname_format.txt for more information.  Edit at your own risk."
+  },
+  {
+    "Command": "filesys.path_cheat",
+    "Description": "Path to directory for cheats."
+  },
+  {
+    "Command": "filesys.path_firmware",
+    "Description": "Path to directory for firmware."
+  },
+  {
+    "Command": "filesys.path_movie",
+    "Description": "Path to directory for movies."
+  },
+  {
+    "Command": "filesys.path_palette",
+    "Description": "Path to directory for custom palettes."
+  },
+  {
+    "Command": "filesys.path_pgconfig",
+    "Description": "Path to directory for per-game configuration override files."
+  },
+  {
+    "Command": "filesys.path_sav",
+    "Description": "Path to directory for save games and nonvolatile memory.\n\nWARNING: Do not set this path to a directory that contains Famicom Disk System disk images, or you will corrupt them when you load an FDS game and exit Mednafen."
+  },
+  {
+    "Command": "filesys.path_savbackup",
+    "Description": "Path to directory for backups of save games and nonvolatile memory."
+  },
+  {
+    "Command": "filesys.path_snap",
+    "Description": "Path to directory for screen snapshots."
+  },
+  {
+    "Command": "filesys.path_state",
+    "Description": "Path to directory for save states."
+  },
+  {
+    "Command": "filesys.state_comp_level",
+    "Description": "Save state file compression level.\n\ngzip/deflate compression level for save states saved to files.  -1 will disable gzip compression and wrapping entirely."
+  },
+  {
+    "Command": "filesys.untrusted_fip_check",
+    "Description": "Enable untrusted file-inclusion path security check.\n\nWhen this setting is set to \"1\", the default, paths to files referenced from files like CUE sheets and PSF rips are checked for certain characters that can be used in directory traversal, and if found, loading is aborted.  Set it to \"0\" if you want to allow constructs like absolute paths in CUE sheets, but only if you understand the security implications of doing so(see \"Security Issues\" section in the documentation)."
+  },
+  {
+    "Command": "input.autofirefreq",
+    "Description": "Auto-fire frequency.\n\nAuto-fire frequency = GameSystemFrameRateHz / (value + 1)"
+  },
+  {
+    "Command": "input.ckdelay",
+    "Description": "Dangerous key action delay.\n\nThe length of time, in milliseconds, that a button/key corresponding to a \"dangerous\" command like power, reset, exit, etc. must be pressed before the command is executed."
+  },
+  {
+    "Command": "input.joystick.axis_threshold",
+    "Description": "Analog axis binary press detection threshold.\n\nThreshold for detecting a digital-like \"button\" press on analog axis, in percent."
+  },
+  {
+    "Command": "input.joystick.global_focus",
+    "Description": "Update physical joystick(s) internal state in Mednafen even when Mednafen lacks OS focus."
+  },
+  {
+    "Command": "netplay.console.font",
+    "Description": "Font for netplay chat console.\n\n<b>5x7</b> - 5x7\n\n\n<b>6x9</b> - 6x9\n\n\n<b>6x12</b> - 6x12\n\n\n<b>6x13</b> - 6x13.  CJK support.\n\n\n<b>9x18</b> - 9x18;  CJK support.\n"
+  },
+  {
+    "Command": "netplay.console.lines",
+    "Description": "Height of chat console, in lines."
+  },
+  {
+    "Command": "netplay.console.scale",
+    "Description": "Netplay chat console text scale factor.\n\nA value of 0 enables auto-scaling."
+  },
+  {
+    "Command": "netplay.gamekey",
+    "Description": "Key to hash with the MD5 hash of the game."
+  },
+  {
+    "Command": "netplay.host",
+    "Description": "Server hostname."
+  },
+  {
+    "Command": "netplay.localplayers",
+    "Description": "Local player count.\n\nNumber of local players for network play.  This number is advisory to the server, and the server may assign fewer players if the number of players requested is higher than the number of controllers currently available."
+  },
+  {
+    "Command": "netplay.nick",
+    "Description": "Nickname.\n\nNickname to use for network play chat."
+  },
+  {
+    "Command": "netplay.password",
+    "Description": "Server password.\n\nPassword to connect to the netplay server."
+  },
+  {
+    "Command": "netplay.port",
+    "Description": "Server port."
+  },
+  {
+    "Command": "nothrottle",
+    "Description": "Disable speed throttling when sound is disabled."
+  },
+  {
+    "Command": "osd.alpha_blend",
+    "Description": "Enable alpha blending for OSD elements."
+  },
+  {
+    "Command": "osd.message_display_time",
+    "Description": "Length of time, in milliseconds, to display internal status and error messages\n\nTime lengths less than 100ms are recommended against unless you understand you may miss important non-fatal error messages, and that the input configuration process may become unusable."
+  },
+  {
+    "Command": "osd.state_display_time",
+    "Description": "Length of time, in milliseconds, to display the save state or the movie selector after selecting a state or movie."
+  },
+  {
+    "Command": "qtrecord.h_double_threshold",
+    "Description": "Double the raw image's height if it's below this threshold."
+  },
+  {
+    "Command": "qtrecord.vcodec",
+    "Description": "Video codec to use.\n\n<b>raw</b> - Raw\nA fast codec, computationally, but will cause enormous file size and may exceed your storage medium's sustained write rate.\n\n<b>cscd</b> - CamStudio Screen Codec\nA good balance between performance and compression ratio.\n\n<b>png</b> - PNG\nHas a better compression ratio than \"cscd\", but is much more CPU intensive.  Use for compatibility with official QuickTime in cases where you have insufficient disk space for \"raw\"."
+  },
+  {
+    "Command": "qtrecord.w_double_threshold",
+    "Description": "Double the raw image's width if it's below this threshold."
+  },
+  {
+    "Command": "sfspeed",
+    "Description": "SLOW-forwarding speed multiplier."
+  },
+  {
+    "Command": "sftoggle",
+    "Description": "Treat the SLOW-forward button as a toggle."
+  },
+  {
+    "Command": "sound",
+    "Description": "Enable sound output."
+  },
+  {
+    "Command": "sound.buffer_time",
+    "Description": "Desired buffer size in milliseconds(ms).\n\nThe default value of 0 enables automatic buffer size selection."
+  },
+  {
+    "Command": "sound.device",
+    "Description": "Select sound output device.\n\nWhen using ALSA sound output under Linux, the \"sound.device\" setting \"default\" is Mednafen's default, IE \"hw:0\", not ALSA's \"default\". If you want to use ALSA's \"default\", use \"sexyal-literal-default\"."
+  },
+  {
+    "Command": "sound.driver",
+    "Description": "Select sound driver.\n\nThe following choices are possible, sorted by preference, high to low, when \"default\" driver is used, but dependent on being compiled in.>\n\n<b>default</b> - Default\nSelects the default sound driver.\n\n<b>alsa</b> - ALSA\nThe default for Linux(if available).\n\n<b>oss</b> - Open Sound System\nThe default for non-Linux UN*X/POSIX/BSD systems, or anywhere ALSA is unavailable. If the ALSA driver gives you problems, you can try using this one instead.\n\n\n\nIf you are using OSSv4 or newer, you should edit \"/usr/lib/oss/conf/osscore.conf\", uncomment the max_intrate= line, and change the value from 100(default) to 1000(or higher if you know what you're doing), and restart OSS. Otherwise, performance will be poor, and the sound buffer size in Mednafen will be orders of magnitude larger than specified.\n\n\n\nIf the sound buffer size is still excessively larger than what is specified via the \"sound.buffer_time\" setting, you can try setting \"sound.period_time\" to 2666, and as a last resort, 5333, to work around a design flaw/limitation/choice in the OSS API and OSS implementation.\n\n<b>wasapish</b> - WASAPI(Shared Mode)\nThe default when it's available(running on Microsoft Windows Vista and newer).\n\n<b>dsound</b> - DirectSound\nThe default for Microsoft Windows XP and older.\n\n<b>wasapi</b> - WASAPI(Exclusive Mode)\nExperimental exclusive-mode WASAPI driver, usable on Windows Vista and newer.  Use it for lower-latency sound.  May not work properly on all sound cards.\n\n<b>sdl</b> - Simple Directmedia Layer\nThis driver is not recommended, but it serves as a backup driver if the others aren't available. Its performance is generally sub-par, requiring higher latency or faster CPUs/SMP for glitch-free playback, except where the OS provides a sound callback API itself, such as with Mac OS X and BeOS.\n\n<b>jack</b> - JACK\nThe latency reported during startup is for the local sound buffer only and does not include server-side latency.  Please note that video card drivers(in the kernel or X), and hardware-accelerated OpenGL, may interfere with jackd's ability to effectively run with realtime response."
+  },
+  {
+    "Command": "sound.period_time",
+    "Description": "Desired period size in microseconds(μs).\n\nCurrently only affects OSS, ALSA, WASAPI(exclusive mode), and SDL output.  A value of 0 defers to the default in the driver code in SexyAL.\n\n\n\nNote: This is not the \"sound buffer size\" setting, that would be \"sound.buffer_time\"."
+  },
+  {
+    "Command": "sound.rate",
+    "Description": "Specifies the sound playback rate, in sound frames per second(\"Hz\")."
+  },
+  {
+    "Command": "sound.volume",
+    "Description": "Sound volume level, in percent.\n\nSetting this volume control higher than the default of \"100\" may severely distort the sound."
+  },
+  {
+    "Command": "srwframes",
+    "Description": "Number of frames to keep states for when state rewinding is enabled.\n\nWARNING: Setting this to a large value may cause excessive RAM usage in some circumstances, such as with games that stream large volumes of data off of CDs."
+  },
+  {
+    "Command": "video.blit_timesync",
+    "Description": "Enable time synchronization(waiting) for frame blitting.\n\nDisable to reduce latency, at the cost of potentially increased video \"juddering\", with the maximum reduction in latency being about 1 video frame's time.\n\nWill work best with emulated systems that are not very computationally expensive to emulate, combined with running on a relatively fast CPU."
+  },
+  {
+    "Command": "video.deinterlacer",
+    "Description": "Deinterlacer to use for interlaced video.\n\n<b>weave</b> - Good for low-motion video; can be used in conjunction with negative <system>.scanlines setting values.\n</system>\n\n<b>bob</b> - Good for causing a headache.  All glory to Bob.\n\n\n<b>bob_offset</b> - Good for high-motion video, but is a bit flickery; reduces the subjective vertical resolution.\n"
+  },
+  {
+    "Command": "video.disable_composition",
+    "Description": "Attempt to disable desktop composition.\n\nCurrently, this setting only has an effect on Windows Vista and Windows 7(and probably the equivalent server versions as well)."
+  },
+  {
+    "Command": "video.driver",
+    "Description": "Video output method/driver.\n\n<b>opengl</b> - OpenGL + SDL\nThis output method is preferred, as all features are available with it.\n\n<b>sdl</b> - SDL Surface\nSlower with lower-quality scaling than OpenGL, but if you don't have hardware-accelerated OpenGL rendering, it will be faster than software OpenGL rendering. Bilinear interpolation not available. Pixel shaders do not work with this output method, of course.\n\n<b>overlay</b> - SDL Overlay\nAs fast as OpenGL, perhaps faster in some situations, *if* it's hardware-accelerated. Scanline effects are not available. hq2x, hq3x, hq4x are not available. The OSD may be missing or glitchy. PSX emulation will not display properly. Bilinear interpolation can't be turned off. Harsh chroma subsampling blurring in some picture types.  If you use this output method, it is strongly recommended to use a special scaler with it, such as nn2x."
+  },
+  {
+    "Command": "video.frameskip",
+    "Description": "Enable frameskip during emulation rendering.\n\nDisable for rendering code performance testing."
+  },
+  {
+    "Command": "video.fs",
+    "Description": "Enable fullscreen mode."
+  },
+  {
+    "Command": "video.glvsync",
+    "Description": "Attempt to synchronize OpenGL page flips to vertical retrace period.\n\nNote: Additionally, if the environment variable \"__GL_SYNC_TO_VBLANK\" does not exist, then it will be created and set to the value specified for this setting.  This has the effect of forcibly enabling or disabling vblank synchronization when running under Linux with NVidia's drivers."
+  },
+  {
+    "Command": "&lt;system&gt;.enable",
+    "Description": "Enable (automatic) usage of this module."
+  },
+  {
+    "Command": "&lt;system&gt;.forcemono",
+    "Description": "Force monophonic sound output."
+  },
+  {
+    "Command": "&lt;system&gt;.pixshader",
+    "Description": "Enable specified OpenGL pixel shader.\n\nObviously, this will only work with the OpenGL \"video.driver\" setting, and only on cards and OpenGL implementations that support pixel shaders, otherwise you will get a black screen, or Mednafen may display an error message when starting up. Bilinear interpolation is disabled with pixel shaders, and any interpolation, if present, will be noted in the description of each pixel shader.>\n\n<b>none</b> - None/Disabled\n\n\n<b>autoip</b> - Auto Interpolation\nWill automatically interpolate on each axis if the corresponding effective scaling factor is not an integer.\n\n<b>autoipsharper</b> - Sharper Auto Interpolation\nSame as \"autoip\", but when interpolation is done, it is done in a manner that will reduce blurriness if possible.\n\n<b>scale2x</b> - Scale2x\n\n\n<b>sabr</b> - SABR v3.0\nGPU-intensive.\n\n<b>ipsharper</b> - Sharper bilinear interpolation.\n\n\n<b>ipxnoty</b> - Linear interpolation on X axis only.\n\n\n<b>ipynotx</b> - Linear interpolation on Y axis only.\n\n\n<b>ipxnotysharper</b> - Sharper version of \"ipxnoty\".\n\n\n<b>ipynotxsharper</b> - Sharper version of \"ipynotx\".\n"
+  },
+  {
+    "Command": "&lt;system&gt;.scanlines",
+    "Description": "Enable scanlines with specified opacity.\n\nOpacity is specified in %; IE a value of \"100\" will give entirely black scanlines.\n\n\n\nNegative values are the same as positive values for non-interlaced video, but for interlaced video will cause the scanlines to be overlaid over the previous field's lines(only if the video.deinterlacer setting is set to \"weave\", the default)."
+  },
+  {
+    "Command": "&lt;system&gt;.special",
+    "Description": "Enable specified special video scaler.\n\nThe destination rectangle is NOT altered by this setting, so if you have xscale and yscale set to \"2\", and try to use a 3x scaling filter like hq3x, the image is not going to look that great. The nearest-neighbor scalers are intended for use with bilinear interpolation enabled, at high resolutions(such as 1280x1024; nn2x(or nny2x) + bilinear interpolation + fullscreen stretching at this resolution looks quite nice).>\n\n<b>none</b> - None/Disabled\n\n\n<b>hq2x</b> - hq2x\n\n\n<b>hq3x</b> - hq3x\n\n\n<b>hq4x</b> - hq4x\n\n\n<b>scale2x</b> - scale2x\n\n\n<b>scale3x</b> - scale3x\n\n\n<b>scale4x</b> - scale4x\n\n\n<b>2xsai</b> - 2xSaI\n\n\n<b>super2xsai</b> - Super 2xSaI\n\n\n<b>supereagle</b> - Super Eagle\n\n\n<b>nn2x</b> - Nearest-neighbor 2x\n\n\n<b>nn3x</b> - Nearest-neighbor 3x\n\n\n<b>nn4x</b> - Nearest-neighbor 4x\n\n\n<b>nny2x</b> - Nearest-neighbor 2x, y axis only\n\n\n<b>nny3x</b> - Nearest-neighbor 3x, y axis only\n\n\n<b>nny4x</b> - Nearest-neighbor 4x, y axis only\n"
+  },
+  {
+    "Command": "&lt;system&gt;.stretch",
+    "Description": "Stretch to fill screen.\n\n<b>0</b> - Disabled\n\n\n<b>full</b> - Full\nFull-screen stretch, disregarding aspect ratio.\n\n<b>aspect</b> - Aspect Preserve\nFull-screen stretch as far as the aspect ratio(in this sense, the equivalent xscalefs == yscalefs) can be maintained.\n\n<b>aspect_int</b> - Aspect Preserve + Integer Scale\nFull-screen stretch, same as \"aspect\" except that the equivalent xscalefs and yscalefs are rounded down to the nearest integer.\n\n<b>aspect_mult2</b> - Aspect Preserve + Integer Multiple-of-2 Scale\nFull-screen stretch, same as \"aspect_int\", but rounds down to the nearest multiple of 2."
+  },
+  {
+    "Command": "&lt;system&gt;.tblur",
+    "Description": "Enable video temporal blur(50/50 previous/current frame by default)."
+  },
+  {
+    "Command": "&lt;system&gt;.tblur.accum",
+    "Description": "Accumulate color data rather than discarding it."
+  },
+  {
+    "Command": "&lt;system&gt;.tblur.accum.amount",
+    "Description": "Blur amount in accumulation mode, specified in percentage of accumulation buffer to mix with the current frame."
+  },
+  {
+    "Command": "&lt;system&gt;.videoip",
+    "Description": "Enable (bi)linear interpolation.\n\n<b>0</b> - Disabled\n\n\n<b>1</b> - Bilinear\n\n\n<b>x</b> - Linear (X)\nInterpolation only on the X axis.\n\n<b>y</b> - Linear (Y)\nInterpolation only on the Y axis."
+  },
+  {
+    "Command": "&lt;system&gt;.xres",
+    "Description": "Full-screen horizontal resolution.\n\nA value of \"0\" will cause the desktop horizontal resolution to be used."
+  },
+  {
+    "Command": "&lt;system&gt;.xscale",
+    "Description": "Scaling factor for the X axis in windowed mode."
+  },
+  {
+    "Command": "&lt;system&gt;.xscalefs",
+    "Description": "Scaling factor for the X axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "&lt;system&gt;.yres",
+    "Description": "Full-screen vertical resolution.\n\nA value of \"0\" will cause the desktop vertical resolution to be used."
+  },
+  {
+    "Command": "&lt;system&gt;.yscale",
+    "Description": "Scaling factor for the Y axis in windowed mode."
+  },
+  {
+    "Command": "&lt;system&gt;.yscalefs",
+    "Description": "Scaling factor for the Y axis in fullscreen mode.\n\nFor this settings to have any effect, the \"<system>.stretch\" setting must be set to \"0\".\n\n</system"
+  },
+  {
+    "Command": "&lt;system&gt;.debugger.disfontsize",
+    "Description": "Disassembly font size.\n\nNote: Setting the font size to larger than the default may cause text overlap in the debugger.>\n\n<b>5x7</b> - 5x7\n\n\n<b>6x9</b> - 6x9\n\n\n<b>6x12</b> - 6x12\n\n\n<b>6x13</b> - 6x13.  CJK support.\n\n\n<b>9x18</b> - 9x18;  CJK support.\n"
+  },
+  {
+    "Command": "&lt;system&gt;.debugger.memcharenc",
+    "Description": "Character encoding for the debugger's memory editor."
+  }
+]
\ No newline at end of file
diff --git a/MedLaunch/MainWindow.xaml b/MedLaunch/MainWindow.xaml
index f40ed67..4b700a8 100644
--- a/MedLaunch/MainWindow.xaml
+++ b/MedLaunch/MainWindow.xaml
@@ -1989,133 +1989,7 @@
                                         <StackPanel Margin="10">
 
 
-                                            <Grid Margin="0">
-
-                                                <Grid.ColumnDefinitions>
-                                                    <ColumnDefinition Width="Auto" />
-                                                    <ColumnDefinition Width="*" />
-                                                </Grid.ColumnDefinitions>
-                                                <Grid.RowDefinitions>
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="*" />
-                                                </Grid.RowDefinitions>
-
-                                                <Label Name="cfglbl_video__driver" Grid.Row="1">Video Driver</Label>
-                                                <ComboBox SelectedValuePath="Tag" Name="cfg_video__driver" Grid.Row="1" Grid.Column="1" Margin="0,0,0,10">
-                                                    <ComboBoxItem Tag="opengl">OpenGL</ComboBoxItem>
-                                                    <ComboBoxItem Tag="sdl">SDL</ComboBoxItem>
-                                                    <ComboBoxItem Tag="overlay">Overlay</ComboBoxItem>
-                                                </ComboBox>
-
-                                                <Label Name="cfglbl_video__deinterlacer" Grid.Row="2">De-interlacer</Label>
-                                                <ComboBox SelectedValuePath="Tag" Name="cfg_video__deinterlacer" Grid.Row="2" Grid.Column="1" Margin="0,0,0,10">
-                                                    <ComboBoxItem Tag="weave">Weave</ComboBoxItem>
-                                                    <ComboBoxItem Tag="bob">Bob</ComboBoxItem>
-                                                    <ComboBoxItem Tag="bob_offset">Bob Offset</ComboBoxItem>
-                                                </ComboBox>
-
-                                                <Label Name="cfglbl___stretch" Grid.Row="3">Stretching</Label>
-                                                <ComboBox SelectedValuePath="Tag" Name="cfg___stretch" Grid.Row="3" Grid.Column="1" Margin="0,0,0,10">
-                                                    <ComboBoxItem Tag="0">Disabled</ComboBoxItem>
-                                                    <ComboBoxItem Tag="full">Full</ComboBoxItem>
-                                                    <ComboBoxItem Tag="aspect">Asp. Preserve</ComboBoxItem>
-                                                    <ComboBoxItem Tag="aspect_int">Asp. Preserve + Int</ComboBoxItem>
-                                                    <ComboBoxItem Tag="aspect_mult2">Asp. Preserve + x2</ComboBoxItem>
-                                                </ComboBox>
-
-                                                <Label Name="cfglbl___videoip" Grid.Row="4">Interpolation</Label>
-                                                <ComboBox SelectedValuePath="Tag" Name="cfg___videoip" Grid.Row="4" Grid.Column="1" Margin="0,0,0,10">
-                                                    <ComboBoxItem Tag="0">Disabled</ComboBoxItem>
-                                                    <ComboBoxItem Tag="1">Bilinear</ComboBoxItem>
-                                                    <ComboBoxItem Tag="x">Linear (X)</ComboBoxItem>
-                                                    <ComboBoxItem Tag="y">Linear (Y)</ComboBoxItem>
-                                                </ComboBox>
-
-                                                <Grid Grid.ColumnSpan="2" Grid.Row="5" Margin="0,5,0,5">
-                                                    <Grid.ColumnDefinitions>
-                                                        <ColumnDefinition Width="0.5*" />
-                                                        <ColumnDefinition Width="0.5*" />
-                                                    </Grid.ColumnDefinitions>
-                                                    <Grid.RowDefinitions>
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                    </Grid.RowDefinitions>
-
-                                                    <Label Name="cfglbl_Generic__fullscreen" Margin="0,10,0,-10" Grid.ColumnSpan="2" Grid.Row="0" HorizontalAlignment="Center">FullScreen Resolution (0 for native)</Label>
-                                                    <Label Name="cfglbl___xres" Grid.Column="0" Grid.Row="1" HorizontalAlignment="Center">Width</Label>
-                                                    <Label Name="cfglbl___yres" Grid.Column="1" Grid.Row="1" HorizontalAlignment="Center">Height</Label>
-
-                                                    <Controls:NumericUpDown Name="cfg___xres" Grid.Column="0" Grid.Row="2" Minimum="0" Maximum="30000" Interval="1"/>
-                                                    <Controls:NumericUpDown Name="cfg___yres" Grid.Column="2" Grid.Row="2" Minimum="0" Maximum="30000" Interval="1"/>
-
-
-                                                    <!--
-                                                    <ComboBox SelectedValuePath="Tag" Name="cfg___xres" Grid.Column="0" Grid.Row="2">
-                                                        <ComboBoxItem Tag="0">Native</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1920">1920</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1856">1856</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1792">1792</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1680">1680</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1600">1600</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1440">1440</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1366">1366</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1280">1280</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1152">1152</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1024">1024</ComboBoxItem>
-                                                        <ComboBoxItem Tag="800">800</ComboBoxItem>
-                                                        <ComboBoxItem Tag="640">640</ComboBoxItem>
-                                                    </ComboBox>
-                                                    <ComboBox SelectedValuePath="Tag" Name="cfg___yres" Grid.Column="2" Grid.Row="2">
-                                                        <ComboBoxItem Tag="0">Native</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1920">1920</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1856">1856</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1792">1792</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1680">1680</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1600">1600</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1440">1440</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1366">1366</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1280">1280</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1152">1152</ComboBoxItem>
-                                                        <ComboBoxItem Tag="1024">1024</ComboBoxItem>
-                                                        <ComboBoxItem Tag="800">800</ComboBoxItem>
-                                                        <ComboBoxItem Tag="640">640</ComboBoxItem>
-                                                    </ComboBox>
-                                                    
-                                                    -->
-
-                                                    <Label Name="cfglbl_Generic__fsscaling" Margin="0,10,0,-10" Grid.ColumnSpan="2" Grid.Row="3" HorizontalAlignment="Center">FullScreen Scaling</Label>
-                                                    <Label Name="cfglbl___xscalefs" Grid.Column="0" Grid.Row="4" HorizontalAlignment="Center">X</Label>
-                                                    <Label Name="cfglbl___yscalefs" Grid.Column="1" Grid.Row="4" HorizontalAlignment="Center">Y</Label>
-                                                    <Controls:NumericUpDown Name="cfg___xscalefs" Grid.Column="0" Grid.Row="5" Minimum="0.01" Maximum="256" Interval="0.01"/>
-                                                    <Controls:NumericUpDown Name="cfg___yscalefs" Grid.Column="1" Grid.Row="5" Minimum="0.01" Maximum="256" Interval="0.01"/>
-
-                                                    <Label Name="cfglbl_Generic__winscaling" Grid.ColumnSpan="2" Grid.Row="6" HorizontalAlignment="Center">Window Scaling</Label>
-                                                    <Label Name="cfglbl_cfg___xscale" Grid.Column="0" Grid.Row="7" HorizontalAlignment="Center">X</Label>
-                                                    <Label Name="cfglbl_cfg___yscale" Grid.Column="1" Grid.Row="7" HorizontalAlignment="Center">Y</Label>
-                                                    <Controls:NumericUpDown Name="cfg___xscale" Grid.Column="0" Grid.Row="8" Minimum="0.01" Maximum="256" Interval="0.01"/>
-                                                    <Controls:NumericUpDown Name="cfg___yscale" Grid.Column="1" Grid.Row="8" Minimum="0.01" Maximum="256" Interval="0.01"/>
-                                                </Grid>
-
-
-
-
-                                            </Grid>
+                                           
 
                                             <CheckBox Name="cfg_video__fs">Full Screen</CheckBox>
                                             <CheckBox Name="cfg_video__frameskip">Frame Skip</CheckBox>
@@ -2133,111 +2007,7 @@
                                         </StackPanel>
                                     </Expander>
                                 </Border>
-                                <!-- Video Filters Border -->
-                                <Border Style="{StaticResource Borders1}" Margin="10" Name="brdNONDYNAMICvfilters">
-                                    <Expander IsExpanded="True" BorderThickness="0" Header="Video Filters">
-                                        <StackPanel Margin="10">
-
-                                            <Grid Margin="0">
-
-                                                <Grid.ColumnDefinitions>
-                                                    <ColumnDefinition Width="Auto" />
-                                                    <ColumnDefinition Width="*" />
-                                                </Grid.ColumnDefinitions>
-                                                <Grid.RowDefinitions>
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="*" />
-                                                </Grid.RowDefinitions>
-
-                                                <Label Name="lbl_Generic__oglpixshader" Grid.Row="1">OGL Pixel Shader</Label>
-                                                <ComboBox SelectedValuePath="Tag" Name="cfg___shader" Grid.Row="1" Grid.Column="1" Margin="0,0,0,10">
-                                                    <ComboBoxItem Tag="none">None/Disabled</ComboBoxItem>
-                                                    <ComboBoxItem Tag="autoip">Auto Interpolation</ComboBoxItem>
-                                                    <ComboBoxItem Tag="autoipsharper">Sharper Auto Interpolation</ComboBoxItem>
-                                                    <ComboBoxItem Tag="scale2x">Scale2x</ComboBoxItem>
-                                                    <ComboBoxItem Tag="sabr">SABR v3.0</ComboBoxItem>
-                                                    <ComboBoxItem Tag="ipsharper">Sharper Bilinear Int.</ComboBoxItem>
-                                                    <ComboBoxItem Tag="ipxnoty">Linear Int. on X Axis</ComboBoxItem>
-                                                    <ComboBoxItem Tag="ipynotx">Linear Int. on Y Axis</ComboBoxItem>
-                                                    <ComboBoxItem Tag="ipxnotysharper">Sharper Lin.Int. on X</ComboBoxItem>
-                                                    <ComboBoxItem Tag="ipynotxsharper">Sharper Lin.Int. on Y</ComboBoxItem>
-                                                    <ComboBoxItem Tag="goat">Goat (Simple Approximation of Color TV CRT)</ComboBoxItem>
-                                                </ComboBox>
-
-                                                <Label Name="lbl_Generic__vscaler" Grid.Row="2">Special Video Scaler</Label>
-                                                <ComboBox SelectedValuePath="Tag" Name="cfg___special" Grid.Row="2" Grid.Column="1" Margin="0,0,0,10">
-                                                    <ComboBoxItem Tag="none">None/Disabled</ComboBoxItem>
-                                                    <ComboBoxItem Tag="hq2x">hq2x</ComboBoxItem>
-                                                    <ComboBoxItem Tag="hq3x">hq3x</ComboBoxItem>
-                                                    <ComboBoxItem Tag="hq4x">hq4x</ComboBoxItem>
-                                                    <ComboBoxItem Tag="scale2x">scale2x</ComboBoxItem>
-                                                    <ComboBoxItem Tag="scale3x">scale3x</ComboBoxItem>
-                                                    <ComboBoxItem Tag="scale4x">scale4x</ComboBoxItem>
-                                                    <ComboBoxItem Tag="2xsai">2xSaI</ComboBoxItem>
-                                                    <ComboBoxItem Tag="super2xsai">Super 2xSaI</ComboBoxItem>
-                                                    <ComboBoxItem Tag="supereagle">Super Eagle</ComboBoxItem>
-                                                    <ComboBoxItem Tag="nn2x">Nearest-neighbor 2x</ComboBoxItem>
-                                                    <ComboBoxItem Tag="nn3x">Nearest-neighbor 3x</ComboBoxItem>
-                                                    <ComboBoxItem Tag="nn4x">Nearest-neighbor 4x</ComboBoxItem>
-                                                    <ComboBoxItem Tag="nny2x">Nearest-neighbor 2x Y Axis</ComboBoxItem>
-                                                    <ComboBoxItem Tag="nny3x">Nearest-neighbor 3x Y Axis</ComboBoxItem>
-                                                    <ComboBoxItem Tag="nny4x">Nearest-neighbor 4x Y Axis</ComboBoxItem>
-                                                </ComboBox>
-
-
-                                                <Grid Grid.ColumnSpan="2" Grid.Row="3" Margin="0,5,0,5">
-                                                    <Grid.ColumnDefinitions>
-                                                        <ColumnDefinition Width="Auto" />
-                                                        <ColumnDefinition Width="*" />
-                                                    </Grid.ColumnDefinitions>
-                                                    <Grid.RowDefinitions>
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                        <RowDefinition Height="Auto" />
-                                                    </Grid.RowDefinitions>
-
-                                                    <DockPanel Grid.ColumnSpan="2" Grid.Row="0" VerticalAlignment="Center" Margin="3">
-                                                        <Label Name="lbl_Generic__scanlines" DockPanel.Dock="Top" VerticalAlignment="Top" HorizontalAlignment="Left">Scanlines</Label>
-                                                        <TextBox Name="tb_Generic__scanlines" Text="{Binding ElementName=cfg___scanlines, Path=Value, UpdateSourceTrigger=PropertyChanged}" DockPanel.Dock="Right" TextAlignment="Right" Width="40" />
-                                                        <Slider Maximum="100" Minimum="-100" TickPlacement="BottomRight" TickFrequency="1" IsSnapToTickEnabled="True" 
-                                        Name="cfg___scanlines"/>
-                                                    </DockPanel>
-
-                                                </Grid>
-                                            </Grid>
-
-                                            <CheckBox Name="cfg___tblur">Temporal Blur</CheckBox>
-                                            <CheckBox Name="cfg___tblur__accum">Accumulate Color Data</CheckBox>
-
-                                            <Grid Margin="0">
-
-                                                <Grid.ColumnDefinitions>
-                                                    <ColumnDefinition Width="Auto" />
-                                                    <ColumnDefinition Width="*" />
-                                                </Grid.ColumnDefinitions>
-                                                <Grid.RowDefinitions>
-                                                    <RowDefinition Height="Auto" />
-                                                    <RowDefinition Height="Auto" />
-
-                                                </Grid.RowDefinitions>
-
-                                                <DockPanel Grid.ColumnSpan="2" Grid.Row="0" VerticalAlignment="Center" Margin="3">
-                                                    <Label Name="lbl_Generic__tbluramount" DockPanel.Dock="Top" VerticalAlignment="Top" HorizontalAlignment="Left">Blur Amount</Label>
-                                                    <TextBox Name="tb_Generic__tbluramount" Text="{Binding ElementName=cfg___tblur__accum__amount, Path=Value, UpdateSourceTrigger=PropertyChanged}" DockPanel.Dock="Right" TextAlignment="Right" Width="40" />
-                                                    <Slider Maximum="50" Minimum="0" TickPlacement="BottomRight" TickFrequency="1" IsSnapToTickEnabled="True" 
-                                        Name="cfg___tblur__accum__amount"/>
-                                                </DockPanel>
-                                            </Grid>
-
-
-                                        </StackPanel>
-                                    </Expander>
-                                </Border>
+                                
                                 <!-- Control Border -->
                                 <Border Style="{StaticResource Borders1}" Margin="10">
                                     <Expander IsExpanded="True" BorderThickness="0" Header="Control">
@@ -5143,8 +4913,8 @@
 
 
                                                 <DockPanel Grid.ColumnSpan="2" Grid.Row="1" VerticalAlignment="Center" Margin="3">
-                                                    <Label DockPanel.Dock="Top" VerticalAlignment="Top" HorizontalAlignment="Left">Mouse Sensitivity</Label>
-                                                    <TextBox Name="cfglbl_pce__mouse_sensitivity" Text="{Binding ElementName=cfg_pce__mouse_sensitivity, Path=Value, UpdateSourceTrigger=PropertyChanged}" DockPanel.Dock="Right" TextAlignment="Right" Width="40" />
+                                                    <Label Name="cfglbl_pce__mouse_sensitivity" DockPanel.Dock="Top" VerticalAlignment="Top" HorizontalAlignment="Left">Mouse Sensitivity</Label>
+                                                    <TextBox  Text="{Binding ElementName=cfg_pce__mouse_sensitivity, Path=Value, UpdateSourceTrigger=PropertyChanged}" DockPanel.Dock="Right" TextAlignment="Right" Width="40" />
                                                     <Slider Maximum="2" Minimum="0.125" TickPlacement="BottomRight" TickFrequency="0.005" IsSnapToTickEnabled="True" 
                                         Name="cfg_pce__mouse_sensitivity"/>
                                                 </DockPanel>
@@ -9547,6 +9317,9 @@
                                                     <RowDefinition Height="Auto" />
                                                     <RowDefinition Height="Auto" />
                                                     <RowDefinition Height="Auto" />
+                                                    <RowDefinition Height="Auto" />
+                                                    <RowDefinition Height="Auto" />
+                                                    <RowDefinition Height="Auto" />
                                                     <RowDefinition Height="*" />
                                                 </Grid.RowDefinitions>
 
@@ -9638,6 +9411,10 @@
                                                     </ComboBox>
 
                                                 </Grid>
+
+                                                <CheckBox Grid.Row="12" Grid.ColumnSpan="2" Name="chkEnableConfigToolTips" Checked="chkEnableConfigToolTips_Checked" Unchecked="chkEnableConfigToolTips_Unchecked">
+                                                    Enable Config ToolTips (requires launcher restart)
+                                                </CheckBox>
                                                 
 
 
@@ -10513,6 +10290,17 @@
                     </Button>
 
 
+                    <Button Margin="5" x:Name="btnGenerateToolTips" Click="btnGenerateToolTips_Click">
+                        Generate tooltips JSON
+                    </Button>
+
+                    <Button Margin="5" x:Name="btnPopToolTips" Click="btnPopToolTips_Click">
+                        ToolTip Populate
+                    </Button>
+
+
+
+
                 </WrapPanel>
             </TabItem>
 
diff --git a/MedLaunch/MainWindow.xaml.cs b/MedLaunch/MainWindow.xaml.cs
index 2c1e4b8..b60d142 100644
--- a/MedLaunch/MainWindow.xaml.cs
+++ b/MedLaunch/MainWindow.xaml.cs
@@ -150,7 +150,7 @@ public MainWindow()
             // load globalsettings for front page
             GlobalSettings.LoadGlobalSettings(chkEnableNetplay, chkEnableSnes_faust, chkEnablePce_fast, gui_zoom_combo, chkMinToTaskbar, chkHideSidebar,
                chkAllowBanners, chkAllowBoxart, chkAllowScreenshots, chkAllowFanart, chkPreferGenesis, chkAllowManuals, chkAllowMedia, chkSecondaryScraperBackup,
-               rbGDB, rbMoby, slScreenshotsPerHost, slFanrtsPerHost, chkAllowUpdateCheck, chkBackupMednafenConfig, chkSaveSysConfigs, comboImageTooltipSize, chkLoadConfigsOnStart,
+               rbGDB, rbMoby, slScreenshotsPerHost, slFanrtsPerHost, chkAllowUpdateCheck, chkBackupMednafenConfig, chkSaveSysConfigs, comboImageTooltipSize, chkLoadConfigsOnStart, chkEnableConfigToolTips,
                chkshowGLYear, chkshowGLESRB, chkshowGLCoop, chkshowGLDeveloper, chkshowGLPublisher, chkshowGLPlayers);
             //gui_zoom.Value = Convert.ToDouble(gui_zoom_combo.SelectedValue);
             GlobalSettings gs = GlobalSettings.GetGlobals();
@@ -326,6 +326,12 @@ public MainWindow()
 
             btnReLink.Visibility = Visibility.Collapsed;
 
+            // enable tooltips if neccesary
+            if (gs.enableConfigToolTips == true)
+            {
+                ConfigToolTips.SetToolTips(1);
+            }
+
         }
 
         private MetroWindow colorSchemeChanger;
@@ -1457,6 +1463,16 @@ private void chkLoadConfigsOnStart_Unchecked(object sender, RoutedEventArgs e)
             GlobalSettings.UpdateImportConfigsOnStart(chkLoadConfigsOnStart);
         }
 
+        private void chkEnableConfigToolTips_Checked(object sender, RoutedEventArgs e)
+        {
+            GlobalSettings.UpdateEnableConfigToolTips(chkEnableConfigToolTips);
+        }
+
+        private void chkEnableConfigToolTips_Unchecked(object sender, RoutedEventArgs e)
+        {
+            GlobalSettings.UpdateEnableConfigToolTips(chkEnableConfigToolTips);
+        }
+
 
 
 
@@ -4057,6 +4073,15 @@ public static string CalculateCombo(List<CheckBox> chkboxes)
             
         }
 
+        private void btnGenerateToolTips_Click(object sender, RoutedEventArgs e)
+        {
+            var r = ConfigToolTips.GetDocumentationStrings();
+        }
+
+        private void btnPopToolTips_Click(object sender, RoutedEventArgs e)
+        {
+            ConfigToolTips.SetToolTips(1);
+        }
     }
     /*
     public class SliderIgnoreDelta : Slider
diff --git a/MedLaunch/MedLaunch.csproj b/MedLaunch/MedLaunch.csproj
index 00f7589..817c534 100644
--- a/MedLaunch/MedLaunch.csproj
+++ b/MedLaunch/MedLaunch.csproj
@@ -237,8 +237,16 @@
     <Compile Include="Classes\CMenu.cs" />
     <Compile Include="Classes\ConfigImport.cs" />
     <Compile Include="Classes\ConfigReflection.cs" />
+    <Compile Include="Classes\ConfigToolTips.cs" />
     <Compile Include="Classes\GamesLibrary\GameListBuilder.cs" />
     <Compile Include="Classes\GamesLibrary\GamesLibraryDataGridRefresh.cs" />
+    <Compile Include="Classes\HtmlToXaml\CssStylesheet.cs" />
+    <Compile Include="Classes\HtmlToXaml\HtmlCSSParser.cs" />
+    <Compile Include="Classes\HtmlToXaml\HtmlLexicalAnalyzer.cs" />
+    <Compile Include="Classes\HtmlToXaml\HtmlParser.cs" />
+    <Compile Include="Classes\HtmlToXaml\HtmlSchema.cs" />
+    <Compile Include="Classes\HtmlToXaml\HtmlTokenType.cs" />
+    <Compile Include="Classes\HtmlToXaml\HtmlToXamlConverter.cs" />
     <Compile Include="Classes\Input\Controller.cs" />
     <Compile Include="Classes\IO\Crypto.cs" />
     <Compile Include="Classes\LogParser.cs" />
@@ -493,6 +501,9 @@
     </None>
     <None Include="Data\System\MobyGames.json" />
     <None Include="Data\System\TheGamesDB.json" />
+    <None Include="Data\System\ToolTips.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="LICENSE">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
diff --git a/MedLaunch/Models/GlobalSettings.cs b/MedLaunch/Models/GlobalSettings.cs
index 1b675bf..b22aca7 100644
--- a/MedLaunch/Models/GlobalSettings.cs
+++ b/MedLaunch/Models/GlobalSettings.cs
@@ -27,6 +27,7 @@ public class GlobalSettings
         public DateTime? gdbLastUpdated { get; set; }               // last time platformgames were synced from thegamesdb.net
         public bool? backupMednafenConfig { get; set; }             // auto create a backup on the mednafen config when MedLaunch is first opened
         public bool? saveSystemConfigs { get; set; }                // auto save system.cfg in root of Mednafen directory before game is launched
+        public bool? enableConfigToolTips { get; set; }             // enable tooltip popups on Mednafen config controls
 
         // games library expander states
         public bool glGameStats { get; set; }
@@ -113,6 +114,7 @@ public static GlobalSettings GetGlobalDefaults()
                 saveSystemConfigs = true,
                 imageToolTipPercentage = 0.9,
                 importConfigsOnStart = false,
+                enableConfigToolTips = true,
 
                 showGLCoop = true,
                 showGLDeveloper = true,
@@ -207,7 +209,7 @@ public static void SetGlobals(GlobalSettings gs)
         public static void LoadGlobalSettings(CheckBox EnableNetplay, CheckBox EnableSnes_Faust, CheckBox EnablePce_Fast, ComboBox GuiZoom, CheckBox MinToTaskBar, CheckBox HideSidebar,
             CheckBox chkAllowBanners, CheckBox chkAllowBoxart, CheckBox chkAllowScreenshots, CheckBox chkAllowFanart, CheckBox chkPreferGenesis, 
             CheckBox chkAllowManuals, CheckBox chkAllowMedia, CheckBox chkSecondaryScraperBackup, RadioButton rbGDB, RadioButton rbMoby, Slider slScreenshotsPerHost, Slider slFanrtsPerHost,
-            CheckBox chkAllowUpdateCheck, CheckBox chkBackupMednafenConfig, CheckBox chkSaveSysConfigs, ComboBox comboImageTooltipSize, CheckBox chkLoadConfigsOnStart,
+            CheckBox chkAllowUpdateCheck, CheckBox chkBackupMednafenConfig, CheckBox chkSaveSysConfigs, ComboBox comboImageTooltipSize, CheckBox chkLoadConfigsOnStart, CheckBox chkEnableConfigToolTips,
             CheckBox chkshowGLYear, CheckBox chkshowGLESRB, CheckBox chkshowGLCoop, CheckBox chkshowGLDeveloper, CheckBox chkshowGLPublisher, CheckBox chkshowGLPlayers)
         {
             GlobalSettings gs = GetGlobals();
@@ -225,6 +227,7 @@ public static void LoadGlobalSettings(CheckBox EnableNetplay, CheckBox EnableSne
 
             chkSaveSysConfigs.IsChecked = gs.saveSystemConfigs;
             chkLoadConfigsOnStart.IsChecked = gs.importConfigsOnStart;
+            chkEnableConfigToolTips.IsChecked = gs.enableConfigToolTips;
 
             comboImageTooltipSize.SelectedValue = gs.imageToolTipPercentage;
 
@@ -395,6 +398,13 @@ public static void UpdateCheckUpdatesOnStart(CheckBox chkAllowUpdateCheck)
             SetGlobals(gs);
         }
 
+        public static void UpdateEnableConfigToolTips(CheckBox chkEnableConfigToolTips)
+        {
+            GlobalSettings gs = GetGlobals();
+            gs.enableConfigToolTips = chkEnableConfigToolTips.IsChecked;
+            SetGlobals(gs);
+        }
+
         // scraping options
         public static void UpdateAllowBanners(CheckBox chkAllowBanners)
         {
diff --git a/MedLaunch/Properties/AssemblyInfo.cs b/MedLaunch/Properties/AssemblyInfo.cs
index abef441..71735b3 100644
--- a/MedLaunch/Properties/AssemblyInfo.cs
+++ b/MedLaunch/Properties/AssemblyInfo.cs
@@ -51,5 +51,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("0.3.4.1")]
-[assembly: AssemblyFileVersion("0.3.4.1")]
+[assembly: AssemblyVersion("0.3.5.0")]
+[assembly: AssemblyFileVersion("0.3.5.0")]