CSS Support

- Very initial support of CSS stylesheets in the SVG via including the
ExCss and Fizzler libraries
- Bug fixes with path rendering
- Improvements to the API for loading an SVG file

Source/External/ExCSS/Model/TextBlocks/UnitBlock.cs

+using System;
+using System.Globalization;
+
+namespace ExCSS.Model.TextBlocks
+{
+    internal class UnitBlock : Block
+    {
+        private string _value;
+
+        UnitBlock(GrammarSegment type)
+        {
+            GrammarSegment = type;
+        }
+
+        internal Single Value
+        {
+            get { return Single.Parse(_value, CultureInfo.InvariantCulture); }
+        }
+
+        internal string Unit { get; private set; }
+
+        internal static UnitBlock Percentage(string value)
+        {
+            return new UnitBlock(GrammarSegment.Percentage) { _value = value, Unit = "%" };
+        }
+
+        internal static UnitBlock Dimension(string value, string dimension)
+        {
+            return new UnitBlock(GrammarSegment.Dimension) { _value = value, Unit = dimension };
+        }
+
+        public override string ToString()
+        {
+            return _value + Unit;
+        }
+    }
+}

Source/External/ExCSS/Model/Values/GenericFunction.cs

+using System.Collections.Generic;
+using System.Text;
+using ExCSS.Model;
+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    public class GenericFunction : Term
+    {
+        public string Name { get; set; }
+        public TermList Arguments { get; set; }
+
+        public GenericFunction(string name, List<Term> arguments)
+        {
+            this.Name = name;
+
+            var list = new TermList();
+            for (int n = 0; n < arguments.Count; n++)
+            {
+                list.AddTerm(arguments[n]);
+                if (n == arguments.Count - 1)
+                    break;
+                list.AddSeparator(GrammarSegment.Comma);
+            }
+            this.Arguments = list;
+        }
+
+        public override string ToString()
+        {
+            return Name + "(" + Arguments + ")";
+        }
+    }
+}
\ No newline at end of file

Source/External/ExCSS/Model/Values/HtmlColor.cs

+using System;
+using System.Runtime.InteropServices;
+using ExCSS.Model;
+using ExCSS.Model.Extensions;
+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    public class HtmlColor : Term, IEquatable<HtmlColor>
+    {
+        public byte A;
+        public byte R;
+        public byte G;
+        public byte B;
+
+        public HtmlColor(byte r, byte g, byte b)
+        {
+            A = 255;
+            R = r;
+            B = b;
+            G = g;
+        }
+
+        public HtmlColor(byte a, byte r, byte g, byte b)
+        {
+            A = a;
+            R = r;
+            B = b;
+            G = g;
+        }
+
+        public HtmlColor(Double a, byte r, byte g, byte b)
+        {
+            A = (byte)Math.Max(Math.Min(Math.Ceiling(255 * a), 255), 0);
+            R = r;
+            B = b;
+            G = g;
+        }
+
+        public static HtmlColor FromRgba(byte r, byte g, byte b, Single a)
+        {
+            return new HtmlColor(a, r, g, b);
+        }
+
+        public static HtmlColor FromRgba(byte r, byte g, byte b, Double a)
+        {
+            return new HtmlColor(a, r, g, b);
+        }
+
+        public static HtmlColor FromRgb(byte r, byte g, byte b)
+        {
+            return new HtmlColor(r, g, b);
+        }
+
+        public static HtmlColor FromHsl(Single h, Single s, Single l)
+        {
+            const Single third = 1f / 3f;
+
+            var m2 = l <= 0.5f ? (l * (s + 1f)) : (l + s - l * s);
+            var m1 = 2f * l - m2;
+            var r = (Byte)Math.Round(255 * HueToRgb(m1, m2, h + third));
+            var g = (Byte)Math.Round(255 * HueToRgb(m1, m2, h));
+            var b = (Byte)Math.Round(255 * HueToRgb(m1, m2, h - third));
+            return new HtmlColor(r, g, b);
+        }
+
+        public static HtmlColor FromHex(string color)
+        {
+            if (color.Length == 3)
+            {
+                var r = color[0].FromHex();
+                r += r * 16;
+
+                var g = color[1].FromHex();
+                g += g * 16;
+                
+                var b = color[2].FromHex();
+                b += b * 16;
+
+                return new HtmlColor((byte)r, (byte)g, (byte)b);
+            }
+           
+            if (color.Length == 6)
+            {
+                var r = 16 * color[0].FromHex();
+                var g = 16 * color[2].FromHex();
+                var b = 16 * color[4].FromHex();
+                
+                r += color[1].FromHex();
+                g += color[3].FromHex();
+                b += color[5].FromHex();
+
+                return new HtmlColor((byte)r, (byte)g, (byte)b);
+            }
+
+            throw new ArgumentException("Invalid color code length: " + color, "color");
+        }
+
+        public static bool TryFromHex(string color, out HtmlColor htmlColor)
+        {
+            htmlColor = new HtmlColor(255, 0, 0, 0);
+
+            if (color.Length == 3)
+            {
+                if (!color[0].IsHex() || !color[1].IsHex() || !color[2].IsHex())
+                {
+                    return false;
+                }
+
+                var r = color[0].FromHex();
+                r += r * 16;
+                
+                var g = color[1].FromHex();
+                g += g * 16;
+                
+                var b = color[2].FromHex();
+                b += b * 16;
+
+                htmlColor.R = (byte)r;
+                htmlColor.G = (byte)g;
+                htmlColor.B = (byte)b;
+                
+                return true;
+            }
+            
+            if (color.Length == 6)
+            {
+                if (!color[0].IsHex() || !color[1].IsHex() || !color[2].IsHex() ||
+                    !color[3].IsHex() || !color[4].IsHex() || !color[5].IsHex())
+                {
+                    return false;
+                }
+
+                var r = 16 * color[0].FromHex();
+                var g = 16 * color[2].FromHex();
+                var b = 16 * color[4].FromHex();
+                
+                r += color[1].FromHex();
+                g += color[3].FromHex();
+                b += color[5].FromHex();
+
+                htmlColor.R = (byte)r;
+                htmlColor.G = (byte)g;
+                htmlColor.B = (byte)b;
+                
+                return true;
+            }
+
+            return false;
+        }
+
+        public double Alpha
+        {
+            get { return A / 255.0; }
+        }
+
+        public static bool operator ==(HtmlColor a, HtmlColor b)
+        {
+            return a.GetHashCode() == b.GetHashCode();
+        }
+
+        public static bool operator !=(HtmlColor a, HtmlColor b)
+        {
+            return a.GetHashCode() != b.GetHashCode();
+        }
+
+        public override bool Equals(Object obj)
+        {
+            if (obj is HtmlColor)
+            {
+                return Equals((HtmlColor)obj);
+            }
+
+            return false;
+        }
+
+        public override int GetHashCode()
+        {
+            return unchecked(A + (R << 8) + (G << 16) + (B << 24));
+        }
+
+        public override string ToString()
+        {
+            return ToString(false);
+        }
+
+        public string ToString(bool friendlyFormat, int indentation = 0)
+        {
+            return ToCss().Indent(friendlyFormat, indentation);
+        }
+
+        public string ToString(bool forceLong, bool friendlyFormat, int indentation = 0)
+        {
+            return ToCss(forceLong).Indent(friendlyFormat, indentation);
+        }
+
+        /// <summary>
+        /// Return the shortest form possible
+        /// </summary>
+        string ToCss(bool forceLong = false)
+        {
+            if (A == 255 && !forceLong && ((R >> 4) == (R & 0x0F)) && ((G >> 4) == (G & 0x0F)) && ((B >> 4) == (B & 0x0F)))
+                return "#" + R.ToHexChar() + G.ToHexChar() + B.ToHexChar();
+
+            if (A == 255)
+            {
+                return "#" + R.ToHex() + G.ToHex() + B.ToHex();
+                //return "rgb(" + R + ", " + G + ", " + B + ")";
+            }
+
+            return "rgba(" + R + ", " + G + ", " + B + ", " + Alpha.ToString("0.##") + ")";
+        }
+
+        public bool Equals(HtmlColor other)
+        {
+            HtmlColor o = other as HtmlColor;
+            if (o == null)
+                return false;
+            return GetHashCode() == other.GetHashCode();
+        }
+
+        private static Single HueToRgb(Single m1, Single m2, Single h)
+        {
+            const Single sixth = 1f / 6f;
+            const Single third2 = 2f / 3f;
+
+            if (h < 0f)
+            {
+                h += 1f;
+            }
+            else if (h > 1f)
+            {
+                h -= 1f;
+            }
+
+            if (h < sixth)
+            {
+                return m1 + (m2 - m1) * h * 6f;
+            }
+            if (h < 0.5)
+            {
+                return m2;
+            }
+            if (h < third2)
+            {
+                return m1 + (m2 - m1) * (third2 - h) * 6f;
+            }
+
+            return m1;
+        }
+    }
+}
\ No newline at end of file

Source/External/ExCSS/Model/Values/InheritTerm.cs

+using System;
+
+namespace ExCSS
+{
+    public class InheritTerm : Term
+    {
+        internal InheritTerm()
+        {
+        }
+
+        public override string ToString()
+        {
+            return "inherit";
+        }
+    }
+}
+

Source/External/ExCSS/Model/Values/PrimitiveTerm.cs

+using System;
+using System.Globalization;
+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    public class PrimitiveTerm : Term
+    {
+        public object Value { get; set; }
+        public UnitType PrimitiveType { get; set; }
+
+        public PrimitiveTerm(UnitType unitType, string value)
+        {
+            PrimitiveType = unitType;
+            Value = value;
+        }
+
+        public PrimitiveTerm(UnitType unitType, Single value)
+        {
+            PrimitiveType = unitType;
+            Value = value;
+        }
+
+        public PrimitiveTerm(string unit, Single value)
+        {
+            PrimitiveType = ConvertStringToUnitType(unit);;
+            Value = value;
+        }
+
+        public Single? GetFloatValue(UnitType unit)
+        {
+            if (!(Value is Single))
+            {
+                return null;
+            }
+
+            var quantity = (Single)Value;
+
+            switch (unit)
+            {
+                case UnitType.Percentage:
+                    quantity = quantity / 100f;
+                    break;
+            }
+
+            return quantity;
+        }
+
+        public override string ToString()
+        {
+            switch (PrimitiveType)
+            {
+                case UnitType.String:
+                    return "'" + Value + "'";
+
+                case UnitType.Uri:
+                    return "url(" + Value + ")";
+
+                default:
+                    if (Value is Single)
+                        return ((Single)Value).ToString(CultureInfo.InvariantCulture) + ConvertUnitTypeToString(PrimitiveType);
+
+                    return Value.ToString();
+            }
+        }
+
+        internal static UnitType ConvertStringToUnitType(string unit)
+        {
+            switch (unit)
+            {
+                case "%":
+                    return UnitType.Percentage;
+                case "em":
+                    return UnitType.Ems;
+                case "cm":
+                    return UnitType.Centimeter;
+                case "deg":
+                    return UnitType.Degree;
+                case "grad":
+                    return UnitType.Grad;
+                case "rad":
+                    return UnitType.Radian;
+                case "turn":
+                    return UnitType.Turn;
+                case "ex":
+                    return UnitType.Exs;
+                case "hz":
+                    return UnitType.Hertz;
+                case "in":
+                    return UnitType.Inch;
+                case "khz":
+                    return UnitType.KiloHertz;
+                case "mm":
+                    return UnitType.Millimeter;
+                case "ms":
+                    return UnitType.Millisecond;
+                case "s":
+                    return UnitType.Second;
+                case "pc":
+                    return UnitType.Percent;
+                case "pt":
+                    return UnitType.Point;
+                case "px":
+                    return UnitType.Pixel;
+                case "vw":
+                    return UnitType.ViewportWidth;
+                case "vh":
+                    return UnitType.ViewportHeight;
+                case "vmin":
+                    return UnitType.ViewportMin;
+                case "vmax":
+                    return UnitType.ViewportMax;
+            }
+
+            return UnitType.Unknown;
+        }
+
+        internal static string ConvertUnitTypeToString(UnitType unit)
+        {
+            switch (unit)
+            {
+                case UnitType.Percentage:
+                    return "%";
+                case UnitType.Ems:
+                    return "em";
+                case UnitType.Centimeter:
+                    return "cm";
+                case UnitType.Degree:
+                    return "deg";
+                case UnitType.Grad:
+                    return "grad";
+                case UnitType.Radian:
+                    return "rad";
+                case UnitType.Turn:
+                    return "turn";
+                case UnitType.Exs:
+                    return "ex";
+                case UnitType.Hertz:
+                    return "hz";
+                case UnitType.Inch:
+                    return "in";
+                case UnitType.KiloHertz:
+                    return "khz";
+                case UnitType.Millimeter:
+                    return "mm";
+                case UnitType.Millisecond:
+                    return "ms";
+                case UnitType.Second:
+                    return "s";
+                case UnitType.Percent:
+                    return "pc";
+                case UnitType.Point:
+                    return "pt";
+                case UnitType.Pixel:
+                    return "px";
+                case UnitType.ViewportWidth:
+                    return "vw";
+                case UnitType.ViewportHeight:
+                    return "vh";
+                case UnitType.ViewportMin:
+                    return "vmin";
+                case UnitType.ViewportMax:
+                    return "vmax";
+            }
+
+            return string.Empty;
+        }
+    }
+}

Source/External/ExCSS/Model/Values/Property.cs

+using ExCSS.Model.Extensions;
+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    public class Property
+    {
+        private Term _term;
+        private bool _important;
+        
+        public Property(string name)
+        {
+            Name = name;
+        }
+
+        public string Name { get; private set; }
+
+        public Term Term
+        {
+            get { return _term; }
+            set { _term = value; }
+        }
+
+        public bool Important
+        {
+            get { return _important; }
+            set { _important = value; }
+        }
+
+        public override string ToString()
+        {
+            return ToString(false);
+        }
+
+        public string ToString(bool friendlyFormat, int indentation = 0)
+        { 
+            var value = Name + ":" + _term;
+
+            if (_important)
+            {
+                value += " !important";
+            }
+
+            return value.Indent(friendlyFormat, indentation);
+        }
+    }
+}

Source/External/ExCSS/Model/Values/Term.cs

+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    public abstract class Term
+    {
+        public static readonly InheritTerm Inherit = new InheritTerm();
+    }
+}

Source/External/ExCSS/Model/Values/TermList.cs

+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    public class TermList : Term
+    {
+        private readonly List<GrammarSegment> _separator = new List<GrammarSegment>();
+        private readonly List<Term> _items = new List<Term>();
+        private const GrammarSegment DefaultSeparator = GrammarSegment.Comma;
+
+        public TermList()
+        {
+        }
+
+        public TermList(params Term[] terms)
+        {
+            for(var i = 0; i < terms.Length; ++i)
+            {
+                AddTerm(terms[i]);
+                if(i != terms.Length-1)
+                {
+                    AddSeparator(DefaultSeparator);
+                }
+            }
+        }
+
+        public void AddTerm(Term term)
+        {
+            if (_items.Count != _separator.Count)
+            {
+                throw new NotSupportedException("Must call AddTerm AddSeparator in that order");
+            }
+
+            _items.Add(term);
+        }
+
+        public void AddSeparator(TermSeparator termSeparator)
+        {
+            switch(termSeparator)
+            {
+                case(TermSeparator.Comma):
+                {
+                    AddSeparator(GrammarSegment.Comma);
+                    break;
+                }
+	             case(TermSeparator.Space):
+                {
+                    AddSeparator(GrammarSegment.Whitespace);
+                    break;
+                }
+            }
+        }
+
+        internal void AddSeparator(GrammarSegment termSepertor)
+        {
+            if (_items.Count != _separator.Count + 1)
+            {
+                throw new NotSupportedException("Must call AddTerm AddSeparator in that order");
+            }
+
+            _separator.Add(termSepertor);
+        }
+
+        public int Length
+        {
+            get { return _items.Count; }
+        }
+
+        [IndexerName("ListItems")]
+        public Term this [int index]
+        {
+            //return index >= 0 && index < _items.Count ? _items[index] : null; 
+            get { return _items[index]; }
+        }
+
+        public Term Item(int index)
+        {
+            return this[index];
+        }
+
+        public override string ToString()
+        {
+            var builder = new StringBuilder();
+
+            for (var i = 0; i < _items.Count; i++)
+            {
+                builder.Append(_items[i]);
+
+                if (i == _separator.Count)
+                    break;
+
+                switch (_separator[i])
+                {
+                    case GrammarSegment.Whitespace:
+                        builder.Append(" ");
+                        break;
+
+                    case GrammarSegment.Comma:
+                        builder.Append(",");
+                        break;
+
+                    default:
+                        throw new NotImplementedException();
+                }
+            }
+
+            return builder.ToString();
+        }
+
+        /// <summary>
+        /// exposed enumeration for the adding of separators into term lists
+        /// </summary>
+        public enum TermSeparator
+        {
+            Comma,
+            Space
+        }
+    }
+}

Source/External/ExCSS/Parser.Blocks.cs

+using System;
+using System.Text;
+using System.Collections.Generic;
+using ExCSS.Model;
+using ExCSS.Model.TextBlocks;
+
+namespace ExCSS
+{
+    public partial class Parser
+    {
+        private bool ParseTokenBlock(Block token)
+        {
+            switch (_parsingContext)
+            {
+                case ParsingContext.DataBlock:
+                    return ParseSymbol(token);
+
+                case ParsingContext.InSelector:
+                    return ParseSelector(token);
+
+                case ParsingContext.InDeclaration:
+                    return ParseDeclaration(token);
+
+                case ParsingContext.AfterProperty:
+                    return ParsePostProperty(token);
+
+                case ParsingContext.BeforeValue:
+                    return ParseValue(token);
+
+                case ParsingContext.InValuePool:
+                    return ParseValuePool(token);
+
+                case ParsingContext.InValueList:
+                    return ParseValueList(token);
+
+                case ParsingContext.InSingleValue:
+                    return ParseSingleValue(token);
+
+                case ParsingContext.ValueImportant:
+                    return ParseImportant(token);
+
+                case ParsingContext.AfterValue:
+                    return ParsePostValue(token);
+
+                case ParsingContext.InMediaList:
+                    return ParseMediaList(token);
+
+                case ParsingContext.InMediaValue:
+                    return ParseMediaValue(token);
+
+                case ParsingContext.BeforeImport:
+                    return ParseImport(token);
+
+                case ParsingContext.AfterInstruction:
+                    return ParsePostInstruction(token);
+
+                case ParsingContext.BeforeCharset:
+                    return ParseCharacterSet(token);
+
+                case ParsingContext.BeforeNamespacePrefix:
+                    return ParseLeadingPrefix(token);
+
+                case ParsingContext.AfterNamespacePrefix:
+                    return ParseNamespace(token);
+
+                case ParsingContext.InCondition:
+                    return ParseCondition(token);
+
+                case ParsingContext.InUnknown:
+                    return ParseUnknown(token);
+
+                case ParsingContext.InKeyframeText:
+                    return ParseKeyframeText(token);
+
+                case ParsingContext.BeforePageSelector:
+                    return ParsePageSelector(token);
+
+                case ParsingContext.BeforeDocumentFunction:
+                    return ParsePreDocumentFunction(token);
+
+                case ParsingContext.InDocumentFunction:
+                    return ParseDocumentFunction(token);
+
+                case ParsingContext.AfterDocumentFunction:
+                    return ParsePostDocumentFunction(token);
+
+                case ParsingContext.BetweenDocumentFunctions:
+                    return ParseDocumentFunctions(token);
+
+                case ParsingContext.BeforeKeyframesName:
+                    return ParseKeyframesName(token);
+
+                case ParsingContext.BeforeKeyframesData:
+                    return ParsePreKeyframesData(token);
+
+                case ParsingContext.KeyframesData:
+                    return ParseKeyframesData(token);
+
+                case ParsingContext.BeforeFontFace:
+                    return ParseFontface(token);
+
+                case ParsingContext.InHexValue:
+                    return ParseHexValue(token);
+
+                case ParsingContext.InFunction:
+
+                    return ParseValueFunction(token);
+                default:
+                    return false;
+            }
+        }
+
+        private bool ParseSymbol(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.AtRule)
+            {
+                switch (((SymbolBlock)token).Value)
+                {
+                    case RuleTypes.Media:
+                        {
+                            AddRuleSet(new MediaRule());
+                            SetParsingContext(ParsingContext.InMediaList);
+                            break;
+                        }
+                    case RuleTypes.Page:
+                        {
+                            AddRuleSet(new PageRule());
+                            //SetParsingContext(ParsingContext.InSelector);
+                            SetParsingContext(ParsingContext.BeforePageSelector);
+                            break;
+                        }
+                    case RuleTypes.Import:
+                        {
+                            AddRuleSet(new ImportRule());
+                            SetParsingContext(ParsingContext.BeforeImport);
+                            break;
+                        }
+                    case RuleTypes.FontFace:
+                        {
+                            AddRuleSet(new FontFaceRule());
+                            //SetParsingContext(ParsingContext.InDeclaration);
+                            SetParsingContext(ParsingContext.BeforeFontFace);
+                            break;
+                        }
+                    case RuleTypes.CharacterSet:
+                        {
+                            AddRuleSet(new CharacterSetRule());
+                            SetParsingContext(ParsingContext.BeforeCharset);
+                            break;
+                        }
+                    case RuleTypes.Namespace:
+                        {
+                            AddRuleSet(new NamespaceRule());
+                            SetParsingContext(ParsingContext.BeforeNamespacePrefix);
+                            break;
+                        }
+                    case RuleTypes.Supports:
+                        {
+                            _buffer = new StringBuilder();
+                            AddRuleSet(new SupportsRule());
+                            SetParsingContext(ParsingContext.InCondition);
+                            break;
+                        }
+                    case RuleTypes.Keyframes:
+                        {
+                            AddRuleSet(new KeyframesRule());
+                            SetParsingContext(ParsingContext.BeforeKeyframesName);
+                            break;
+                        }
+                    case RuleTypes.Document:
+                        {
+                            AddRuleSet(new DocumentRule());
+                            SetParsingContext(ParsingContext.BeforeDocumentFunction);
+                            break;
+                        }
+                    default:
+                        {
+                            _buffer = new StringBuilder();
+                            AddRuleSet(new GenericRule());
+                            SetParsingContext(ParsingContext.InUnknown);
+                            ParseUnknown(token);
+                            break;
+                        }
+                }
+
+                return true;
+            }
+
+            if (token.GrammarSegment == GrammarSegment.CurlyBracketClose)
+            {
+                return FinalizeRule();
+            }
+
+            AddRuleSet(new StyleRule());
+            SetParsingContext(ParsingContext.InSelector);
+            ParseSelector(token);
+            return true;
+
+        }
+
+        private bool ParseUnknown(Block token)
+        {
+            switch (token.GrammarSegment)
+            {
+                case GrammarSegment.Semicolon:
+                    CastRuleSet<GenericRule>().SetInstruction(_buffer.ToString());
+                    SetParsingContext(ParsingContext.DataBlock);
+
+                    return FinalizeRule();
+
+                case GrammarSegment.CurlyBraceOpen:
+                    CastRuleSet<GenericRule>().SetCondition(_buffer.ToString());
+                    SetParsingContext(ParsingContext.DataBlock);
+                    break;
+
+                default:
+                    _buffer.Append(token);
+                    break;
+            }
+
+            return true;
+        }
+
+        private bool ParseSelector(Block token)
+        {
+            switch (token.GrammarSegment)
+            {
+                case GrammarSegment.CurlyBraceOpen:
+                    {
+                        var rule = CurrentRule as ISupportsSelector;
+
+                        if (rule != null)
+                        {
+                            rule.Selector = _selectorFactory.GetSelector();
+                        }
+
+                        SetParsingContext(CurrentRule is StyleRule
+                            ? ParsingContext.InDeclaration
+                            : ParsingContext.DataBlock);
+                    }
+                    break;
+
+                case GrammarSegment.CurlyBracketClose:
+                    return false;
+
+                default:
+                    _selectorFactory.Apply(token);
+                    break;
+            }
+
+            return true;
+        }
+
+        private bool ParseDeclaration(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.CurlyBracketClose)
+            {
+                FinalizeProperty();
+                SetParsingContext(CurrentRule is KeyframeRule ? ParsingContext.KeyframesData : ParsingContext.DataBlock);
+                return FinalizeRule();
+            }
+
+            if (token.GrammarSegment != GrammarSegment.Ident)
+            {
+                return false;
+            }
+
+            AddProperty(new Property(((SymbolBlock)token).Value));
+            SetParsingContext(ParsingContext.AfterProperty);
+            return true;
+        }
+
+        private bool ParsePostInstruction(Block token)
+        {
+            if (token.GrammarSegment != GrammarSegment.Semicolon)
+            {
+                return false;
+            }
+
+            SetParsingContext(ParsingContext.DataBlock);
+
+            return FinalizeRule();
+        }
+
+        private bool ParseCondition(Block token)
+        {
+            switch (token.GrammarSegment)
+            {
+                case GrammarSegment.CurlyBraceOpen:
+                    CastRuleSet<SupportsRule>().Condition = _buffer.ToString();
+                    SetParsingContext(ParsingContext.DataBlock);
+                    break;
+
+                default:
+                    _buffer.Append(token);
+                    break;
+            }
+
+            return true;
+        }
+
+        private bool ParseLeadingPrefix(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.Ident)
+            {
+                CastRuleSet<NamespaceRule>().Prefix = ((SymbolBlock)token).Value;
+                SetParsingContext(ParsingContext.AfterNamespacePrefix);
+
+                return true;
+            }
+
+            if (token.GrammarSegment == GrammarSegment.String || token.GrammarSegment == GrammarSegment.Url)
+            {
+                CastRuleSet<NamespaceRule>().Uri = ((StringBlock)token).Value;
+                return true;
+            }
+
+            SetParsingContext(ParsingContext.AfterInstruction);
+
+            return ParsePostInstruction(token);
+        }
+
+        private bool ParsePostProperty(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.Colon)
+            {
+                _isFraction = false;
+                SetParsingContext(ParsingContext.BeforeValue);
+                return true;
+            }
+
+            if (token.GrammarSegment == GrammarSegment.Semicolon || token.GrammarSegment == GrammarSegment.CurlyBracketClose)
+            {
+                ParsePostValue(token);
+            }
+
+            return false;
+        }
+
+        private bool ParseValue(Block token)
+        {
+            switch (token.GrammarSegment)
+            {
+                case GrammarSegment.Semicolon:
+                    SetParsingContext(ParsingContext.InDeclaration);
+                    break;
+
+                case GrammarSegment.CurlyBracketClose:
+                    ParseDeclaration(token);
+                    break;
+
+                default:
+                    SetParsingContext(ParsingContext.InSingleValue);
+                    return ParseSingleValue(token);
+            }
+
+            return false;
+        }
+
+        private bool ParseSingleValue(Block token)
+        {
+            switch (token.GrammarSegment)
+            {
+                case GrammarSegment.Dimension: // "3px"
+                    return AddTerm(new PrimitiveTerm(((UnitBlock)token).Unit, ((UnitBlock)token).Value));
+
+                case GrammarSegment.Hash:// "#ffffff"
+                    return ParseSingleValueHexColor(((SymbolBlock)token).Value);
+
+                case GrammarSegment.Delimiter: // "#"
+                    return ParseValueDelimiter((DelimiterBlock)token);
+
+                case GrammarSegment.Ident: // "auto"
+                    return ParseSingleValueIdent((SymbolBlock)token);
+
+                case GrammarSegment.String:// "'some value'"
+                    return AddTerm(new PrimitiveTerm(UnitType.String, ((StringBlock)token).Value));
+
+                case GrammarSegment.Url:// "url('http://....')"
+                    return AddTerm(new PrimitiveTerm(UnitType.Uri, ((StringBlock)token).Value));
+
+                case GrammarSegment.Percentage: // "10%"
+                    return AddTerm(new PrimitiveTerm(UnitType.Percentage, ((UnitBlock)token).Value));
+
+                case GrammarSegment.Number: // "123"
+                    return AddTerm(new PrimitiveTerm(UnitType.Number, ((NumericBlock)token).Value));
+
+                case GrammarSegment.Whitespace: // " "
+                    _terms.AddSeparator(GrammarSegment.Whitespace);
+                    SetParsingContext(ParsingContext.InValueList);
+                    return true;
+
+                case GrammarSegment.Function: // rgba(...)
+                    _functionBuffers.Push(new FunctionBuffer(((SymbolBlock)token).Value));
+                    SetParsingContext(ParsingContext.InFunction);
+                    return true;
+
+                case GrammarSegment.Comma: // ","
+                    _terms.AddSeparator(GrammarSegment.Comma);
+                    SetParsingContext(ParsingContext.InValuePool);
+                    return true;
+
+                case GrammarSegment.Semicolon: // ";"
+                case GrammarSegment.CurlyBracketClose: // "}"
+                    return ParsePostValue(token);
+
+                default:
+                    return false;
+            }
+        }
+
+        private bool ParseValueFunction(Block token)
+        {
+            switch (token.GrammarSegment)
+            {
+                case GrammarSegment.ParenClose:
+                    SetParsingContext(ParsingContext.InSingleValue);
+                    return AddTerm(_functionBuffers.Pop().Done());
+
+                case GrammarSegment.Comma:
+                    _functionBuffers.Peek().Include();
+                    return true;
+
+                default:
+                    return ParseSingleValue(token);
+            }
+        }
+
+        private bool ParseValueList(Block token)
+        {
+            switch (token.GrammarSegment)
+            {
+                case GrammarSegment.CurlyBracketClose:
+                case GrammarSegment.Semicolon:
+                    ParsePostValue(token);
+                    break;
+
+                case GrammarSegment.Comma:
+                    SetParsingContext(ParsingContext.InValuePool);
+                    break;
+
+                default:
+                    SetParsingContext(ParsingContext.InSingleValue);
+                    return ParseSingleValue(token);
+            }
+
+            return true;
+        }
+
+        private bool ParseValuePool(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.Semicolon || token.GrammarSegment == GrammarSegment.CurlyBracketClose)
+            {
+                ParsePostValue(token);
+            }
+            else
+            {
+                SetParsingContext(ParsingContext.InSingleValue);
+                return ParseSingleValue(token);
+            }
+
+            return false;
+        }
+
+        private bool ParseHexValue(Block token)
+        {
+            switch (token.GrammarSegment)
+            {
+                case GrammarSegment.Number:
+                case GrammarSegment.Dimension:
+                case GrammarSegment.Ident:
+                    var rest = token.ToString();
+
+                    if (_buffer.Length + rest.Length <= 6)
+                    {
+                        _buffer.Append(rest);
+                        return true;
+                    }
+
+                    break;
+            }
+
+            ParseSingleValueHexColor(_buffer.ToString());
+            SetParsingContext(ParsingContext.InSingleValue);
+            return ParseSingleValue(token);
+        }
+
+        private bool ParsePostValue(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.Semicolon)
+            {
+                FinalizeProperty();
+                SetParsingContext(ParsingContext.InDeclaration);
+                return true;
+            }
+
+            if (token.GrammarSegment == GrammarSegment.CurlyBracketClose)
+            {
+                return ParseDeclaration(token);
+            }
+
+            return false;
+        }
+
+        private bool ParseImportant(Block token)
+        {
+            if (token.GrammarSegment != GrammarSegment.Ident || ((SymbolBlock)token).Value != "important")
+            {
+                return ParsePostValue(token);
+            }
+
+            SetParsingContext(ParsingContext.AfterValue);
+            _property.Important = true;
+
+            return true;
+        }
+
+        private bool ParseValueDelimiter(DelimiterBlock token)
+        {
+            switch (token.Value)
+            {
+                case Specification.Em:
+                    SetParsingContext(ParsingContext.ValueImportant);
+                    return true;
+
+                case Specification.Hash:
+                    _buffer = new StringBuilder();
+                    SetParsingContext(ParsingContext.InHexValue);
+                    return true;
+
+                case Specification.Solidus:
+                    _isFraction = true;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private bool ParseSingleValueIdent(SymbolBlock token)
+        {
+            if (token.Value != "inherit")
+            {
+                return AddTerm(new PrimitiveTerm(UnitType.Ident, token.Value));
+            }
+            _terms.AddTerm(Term.Inherit);
+            SetParsingContext(ParsingContext.AfterValue);
+            return true;
+        }
+
+        private bool ParseSingleValueHexColor(string color)
+        {
+            HtmlColor htmlColor;
+
+            if(HtmlColor.TryFromHex(color, out htmlColor))
+                return AddTerm(htmlColor);
+            return false;
+        }
+
+        #region Namespace
+        private bool ParseNamespace(Block token)
+        {
+            SetParsingContext(ParsingContext.AfterInstruction);
+
+            if (token.GrammarSegment != GrammarSegment.String)
+            {
+                return ParsePostInstruction(token);
+            }
+
+            CastRuleSet<NamespaceRule>().Uri = ((StringBlock)token).Value;
+
+            return true;
+        }
+        #endregion
+
+        #region Charset
+        private bool ParseCharacterSet(Block token)
+        {
+            SetParsingContext(ParsingContext.AfterInstruction);
+
+            if (token.GrammarSegment != GrammarSegment.String)
+            {
+                return ParsePostInstruction(token);
+            }
+
+            CastRuleSet<CharacterSetRule>().Encoding = ((StringBlock)token).Value;
+
+            return true;
+        }
+        #endregion
+
+        #region Import
+        private bool ParseImport(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.String || token.GrammarSegment == GrammarSegment.Url)
+            {
+                CastRuleSet<ImportRule>().Href = ((StringBlock)token).Value;
+                SetParsingContext(ParsingContext.InMediaList);
+                return true;
+            }
+
+            SetParsingContext(ParsingContext.AfterInstruction);
+
+            return false;
+        }
+        #endregion
+
+        #region Font Face
+
+        private bool ParseFontface(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.CurlyBraceOpen)
+            {
+                SetParsingContext(ParsingContext.InDeclaration);
+                return true;
+            }
+
+            return false;
+        }
+        #endregion
+
+        #region Keyframes
+        private bool ParseKeyframesName(Block token)
+        {
+            //SetParsingContext(ParsingContext.BeforeKeyframesData);
+
+            if (token.GrammarSegment == GrammarSegment.Ident)
+            {
+                CastRuleSet<KeyframesRule>().Identifier = ((SymbolBlock)token).Value;
+                return true;
+            }
+
+            if (token.GrammarSegment == GrammarSegment.CurlyBraceOpen)
+            {
+                SetParsingContext(ParsingContext.KeyframesData);
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool ParsePreKeyframesData(Block token)
+        {
+            if (token.GrammarSegment != GrammarSegment.CurlyBraceOpen)
+            {
+                return false;
+            }
+
+            SetParsingContext(ParsingContext.BeforeKeyframesData);
+            return true;
+        }
+
+        private bool ParseKeyframesData(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.CurlyBracketClose)
+            {
+                SetParsingContext(ParsingContext.DataBlock);
+                return FinalizeRule();
+            }
+
+            _buffer = new StringBuilder();
+         
+            return ParseKeyframeText(token);
+        }
+
+        private bool ParseKeyframeText(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.CurlyBraceOpen)
+            {
+                SetParsingContext(ParsingContext.InDeclaration);
+                return true;
+            }
+
+            if (token.GrammarSegment == GrammarSegment.CurlyBracketClose)
+            {
+                ParseKeyframesData(token);
+
+                return false;
+            }
+
+            var frame = new KeyframeRule
+            {
+                Value = token.ToString()
+            };
+
+
+            CastRuleSet<KeyframesRule>().Declarations.Add(frame);
+            _activeRuleSets.Push(frame);
+
+            return true;
+        }
+        #endregion
+
+        #region Page
+
+        private bool ParsePageSelector(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.Colon || token.GrammarSegment == GrammarSegment.Whitespace)
+            {
+                return true;
+            }
+
+            if (token.GrammarSegment == GrammarSegment.Ident)
+            {
+                CastRuleSet<PageRule>().Selector = new SimpleSelector(token.ToString());
+                return true;
+            }
+
+            if (token.GrammarSegment == GrammarSegment.CurlyBraceOpen)
+            {
+                SetParsingContext(ParsingContext.InDeclaration);
+                return true;
+            }
+
+            return false;
+        }
+        
+        #endregion
+
+        #region Document
+        private bool ParsePreDocumentFunction(Block token)
+        {
+            switch (token.GrammarSegment)
+            {
+                case GrammarSegment.Url:
+                    CastRuleSet<DocumentRule>().Conditions.Add(new KeyValuePair<DocumentFunction, string>(DocumentFunction.Url, ((StringBlock)token).Value));
+                    break;
+
+                case GrammarSegment.UrlPrefix:
+                    CastRuleSet<DocumentRule>().Conditions.Add(new KeyValuePair<DocumentFunction, string>(DocumentFunction.UrlPrefix, ((StringBlock)token).Value));
+                    break;
+
+                case GrammarSegment.Domain:
+                    CastRuleSet<DocumentRule>().Conditions.Add(new KeyValuePair<DocumentFunction, string>(DocumentFunction.Domain, ((StringBlock)token).Value));
+                    break;
+
+                case GrammarSegment.Function:
+                    if (string.Compare(((SymbolBlock)token).Value, "regexp", StringComparison.OrdinalIgnoreCase) == 0)
+                    {
+                        SetParsingContext(ParsingContext.InDocumentFunction);
+                        return true;
+                    }
+                    SetParsingContext(ParsingContext.AfterDocumentFunction);
+                    return false;
+
+                default:
+                    SetParsingContext(ParsingContext.DataBlock);
+                    return false;
+            }
+
+            SetParsingContext(ParsingContext.BetweenDocumentFunctions);
+            return true;
+        }
+
+        private bool ParseDocumentFunction(Block token)
+        {
+            SetParsingContext(ParsingContext.AfterDocumentFunction);
+
+            if (token.GrammarSegment != GrammarSegment.String) return false;
+            CastRuleSet<DocumentRule>().Conditions.Add(new KeyValuePair<DocumentFunction, string>(DocumentFunction.RegExp, ((StringBlock)token).Value));
+            return true;
+        }
+
+        private bool ParsePostDocumentFunction(Block token)
+        {
+            SetParsingContext(ParsingContext.BetweenDocumentFunctions);
+            return token.GrammarSegment == GrammarSegment.ParenClose;
+        }
+
+        private bool ParseDocumentFunctions(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.Comma)
+            {
+                SetParsingContext(ParsingContext.BeforeDocumentFunction);
+                return true;
+            }
+
+            if (token.GrammarSegment == GrammarSegment.CurlyBraceOpen)
+            {
+                SetParsingContext(ParsingContext.DataBlock);
+                return true;
+            }
+
+            SetParsingContext(ParsingContext.DataBlock);
+            return false;
+        }
+        #endregion
+
+        #region Media
+        private bool ParseMediaList(Block token)
+        {
+            if (token.GrammarSegment == GrammarSegment.Semicolon)
+            {
+                FinalizeRule();
+                SetParsingContext(ParsingContext.DataBlock);
+                return true;
+            }
+
+            _buffer = new StringBuilder();
+            SetParsingContext(ParsingContext.InMediaValue);
+            return ParseMediaValue(token);
+        }
+
+        private bool ParseMediaValue(Block token)
+        {
+            switch (token.GrammarSegment)
+            {
+                case GrammarSegment.CurlyBraceOpen:
+                case GrammarSegment.Semicolon:
+                    {
+                        var container = CurrentRule as ISupportsMedia;
+                        var medium = _buffer.ToString();
+
+                        if (container != null)
+                        {
+                            container.Media.AppendMedium(medium);
+                        }
+
+                        if (CurrentRule is ImportRule)
+                        {
+                            return ParsePostInstruction(token);
+                        }
+
+                        SetParsingContext(ParsingContext.DataBlock);
+                        return token.GrammarSegment == GrammarSegment.CurlyBraceOpen;
+                    }
+                case GrammarSegment.Comma:
+                    {
+                        var container = CurrentRule as ISupportsMedia;
+
+                        if (container != null)
+                        {
+                            container.Media.AppendMedium(_buffer.ToString());
+                        }
+
+                        _buffer.Length = 0;
+                        return true;
+                    }
+                case GrammarSegment.Whitespace:
+                    {
+                        _buffer.Append(' ');
+                        return true;
+                    }
+                default:
+                    {
+                        _buffer.Append(token);
+                        return true;
+                    }
+            }
+        }
+        #endregion
+    }
+}

Source/External/ExCSS/Parser.cs

+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using ExCSS.Model;
+using ExCSS.Model.TextBlocks;
+
+// ReSharper disable once CheckNamespace
+using System;
+
+
+namespace ExCSS
+{
+    internal delegate void ParseErrorEventHandler(StylesheetParseError e);
+
+    public sealed partial class Parser
+    {
+        private SelectorFactory _selectorFactory;
+        private Stack<FunctionBuffer> _functionBuffers;
+        private Lexer _lexer;
+        private bool _isFraction;
+        private Property _property;
+        private TermList _terms = new TermList();
+        private StyleSheet _styleSheet;
+        private Stack<RuleSet> _activeRuleSets;
+        private StringBuilder _buffer;
+        private ParsingContext _parsingContext;
+
+        public StyleSheet Parse(string css)
+        {
+            _selectorFactory = new SelectorFactory();
+            _functionBuffers = new Stack<FunctionBuffer>();
+            _styleSheet = new StyleSheet();
+            _activeRuleSets = new Stack<RuleSet>();
+            _lexer = new Lexer(new StylesheetReader(css)) { ErrorHandler = HandleLexerError };
+
+            SetParsingContext(ParsingContext.DataBlock);
+
+            var tokens = _lexer.Tokens;
+
+            foreach (var token in tokens)
+            {
+                if (ParseTokenBlock(token))
+                {
+                    continue;
+                }
+
+                HandleLexerError(ParserError.UnexpectedLineBreak, ErrorMessages.Default);
+            }
+
+            if (_property != null)
+            {
+                ParseTokenBlock(SpecialCharacter.Semicolon);
+            }
+
+            return _styleSheet;
+        }
+
+        internal static BaseSelector ParseSelector(string selector)
+        {
+            var tokenizer = new Lexer(new StylesheetReader(selector));
+            var tokens = tokenizer.Tokens;
+            var selctor = new SelectorFactory();
+
+            foreach (var token in tokens)
+            {
+                selctor.Apply(token);
+            }
+
+            var result = selctor.GetSelector();
+
+            return result;
+        }
+
+        internal static RuleSet ParseRule(string css)
+        {
+            var parser = new Parser();
+            
+
+            var styleSheet = parser.Parse(css);
+
+            return styleSheet.Rules.Count > 0
+                ? styleSheet.Rules[0] 
+                : null;
+        }
+
+        internal static StyleDeclaration ParseDeclarations(string declarations, bool quirksMode = false)
+        {
+            var decl = new StyleDeclaration();
+            AppendDeclarations(decl, declarations, quirksMode);
+
+            return decl;
+        }
+
+        internal static void AppendDeclarations(StyleDeclaration list, string css, bool quirksMode = false)
+        {
+            var parser = new Parser();//(new StyleSheet(), new StylesheetReader(declarations))
+           
+
+            parser.AddRuleSet(list.ParentRule ?? new StyleRule(list));
+
+            parser._parsingContext = ParsingContext.InDeclaration;
+            parser.Parse(css);
+        }
+
+        internal void HandleLexerError(ParserError error, string message)
+        {
+            _styleSheet.Errors.Add(new StylesheetParseError(error, message, _lexer.Stream.Line, _lexer.Stream.Column));
+        }
+
+        private bool AddTerm(Term value)
+        {
+            if (_isFraction)
+            {
+                if (_terms.Length > 0)
+                {
+                    value = new PrimitiveTerm(UnitType.Unknown, _terms[0] + "/" + value);
+                    _terms = new TermList();
+                }
+
+                _isFraction = false;
+            }
+
+            if (_functionBuffers.Count > 0)
+            {
+                _functionBuffers.Peek().TermList.Add(value);
+            }
+            else if (_terms.Length == 0)
+            {
+                _terms.AddTerm(value);
+            }
+            else if (_parsingContext == ParsingContext.InSingleValue)
+            {
+                _terms.AddTerm(value);
+            }
+            else
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        private void FinalizeProperty()
+        {
+            if (_property != null)
+            {
+                if (_terms.Length > 1)
+                {
+                    _property.Term = _terms;
+                }
+                else
+                {
+                    _property.Term = _terms[0];
+                }
+            }
+
+            _terms = new TermList();
+            _property = null;
+        }
+
+        private bool FinalizeRule()
+        {
+            if (_activeRuleSets.Count <= 0)
+            {
+                return false;
+            }
+
+            _activeRuleSets.Pop();
+            return true;
+        }
+
+        private void AddRuleSet(RuleSet rule)
+        {
+            //rule.ParentStyleSheet = _styleSheet;
+
+            if (_activeRuleSets.Count > 0)
+            {
+                var container = _activeRuleSets.Peek() as ISupportsRuleSets;
+
+                if (container != null)
+                {
+                    container.RuleSets.Add(rule);
+                }
+            }
+            else
+            {
+                _styleSheet.Rules.Add(rule);
+            }
+
+            _activeRuleSets.Push(rule);
+        }
+
+        private void AddProperty(Property property)
+        {
+            _property = property;
+            var rule = CurrentRule as ISupportsDeclarations;
+
+            if (rule != null)
+            {
+                rule.Declarations.Add(property);
+            }
+        }
+
+        private T CastRuleSet<T>() where T : RuleSet
+        {
+            if (_activeRuleSets.Count > 0)
+            {
+                return _activeRuleSets.Peek() as T;
+            }
+
+            return default(T);
+        }
+
+        private void SetParsingContext(ParsingContext newState)
+        {
+            switch (newState)
+            {
+                case ParsingContext.InSelector:
+                    _lexer.IgnoreComments = true;
+                    _lexer.IgnoreWhitespace = false;
+                    _selectorFactory.ResetFactory();
+                    break;
+
+                case ParsingContext.InHexValue:
+                case ParsingContext.InUnknown:
+                case ParsingContext.InCondition:
+                case ParsingContext.InSingleValue:
+                case ParsingContext.InMediaValue:
+                    _lexer.IgnoreComments = true;
+                    _lexer.IgnoreWhitespace = false;
+                    break;
+
+                default:
+                    _lexer.IgnoreComments = true;
+                    _lexer.IgnoreWhitespace = true;
+                    break;
+            }
+
+            _parsingContext = newState;
+        }
+
+        internal RuleSet CurrentRule
+        {
+            get
+            {
+                return _activeRuleSets.Count > 0
+                    ? _activeRuleSets.Peek()
+                    : null;
+            }
+        }
+    }
+}

Source/External/ExCSS/Parser.generated.cs

+
+/* #line 1 "Parser.rl" */
+using System;
+using ExCSS.Model;
+
+namespace ExCSS
+{
+	public class Parser
+	{
+		private string _css;
+		private int _currentPosition;
+		private int p = 0;
+		private StylesheetContext _context;
+		
+		
+/* #line 17 "Parser.rl" */
+
+
+		private string GetCssFragment() {
+			return _css.Substring(_currentPosition, p - _currentPosition);
+		}
+		
+		private void BeginToken(TokenType tokenType){
+			_currentPosition = p;
+			_context.BeginToken(tokenType);
+		}
+
+		private void EndToken(TokenType tokenType){
+			_context.EndToken(tokenType, GetCssFragment());
+		}
+
+		#region Generated Scanner + Parser
+		public void Parse(string value, StylesheetContext context)
+		{
+		    _css = value;
+		    _context = context;
+
+			char[] data = value.ToCharArray();
+			int cs;
+			int eof = data.Length;
+			
+			int pe = eof;
+			
+			
+/* #line 2 "../ExCSS/Parser.generated.cs" */
+	{
+	cs = selector_start;
+	}
+
+/* #line 45 "Parser.rl" */
+			
+/* #line 5 "../ExCSS/Parser.generated.cs" */
+	{
+	sbyte _klen;
+	short _trans;
+	short _keys;
+
+	if ( p == pe )
+		goto _test_eof;
+	if ( cs == 0 )
+		goto _out;
+_resume:
+	_keys = _selector_key_offsets[cs];
+	_trans = (short)_selector_index_offsets[cs];
+
+	_klen = _selector_single_lengths[cs];
+	if ( _klen > 0 ) {
+		short _lower = _keys;
+		short _mid;
+		short _upper = (short) (_keys + _klen - 1);
+		while (true) {
+			if ( _upper < _lower )
+				break;
+
+			_mid = (short) (_lower + ((_upper-_lower) >> 1));
+			if ( data[p] < _selector_trans_keys[_mid] )
+				_upper = (short) (_mid - 1);
+			else if ( data[p] > _selector_trans_keys[_mid] )
+				_lower = (short) (_mid + 1);
+			else {
+				_trans += (short) (_mid - _keys);
+				goto _match;
+			}
+		}
+		_keys += (short) _klen;
+		_trans += (short) _klen;
+	}
+
+	_klen = _selector_range_lengths[cs];
+	if ( _klen > 0 ) {
+		short _lower = _keys;
+		short _mid;
+		short _upper = (short) (_keys + (_klen<<1) - 2);
+		while (true) {
+			if ( _upper < _lower )
+				break;
+
+			_mid = (short) (_lower + (((_upper-_lower) >> 1) & ~1));
+			if ( data[p] < _selector_trans_keys[_mid] )
+				_upper = (short) (_mid - 2);
+			else if ( data[p] > _selector_trans_keys[_mid+1] )
+				_lower = (short) (_mid + 2);
+			else {
+				_trans += (short)((_mid - _keys)>>1);
+				goto _match;
+			}
+		}
+		_trans += (short) _klen;
+	}
+
+_match:
+	cs = _selector_trans_targs[_trans];
+
+	if ( cs == 0 )
+		goto _out;
+	if ( ++p != pe )
+		goto _resume;
+	_test_eof: {}
+	_out: {}
+	}
+
+/* #line 46 "Parser.rl" */
+		}
+		
+		
+/* #line 73 "../ExCSS/Parser.generated.cs" */
+static readonly short[] _selector_key_offsets =  new short [] {
+	0, 0, 12, 16, 27, 31, 49, 50, 
+	72, 74, 76, 78, 80, 82, 84, 86, 
+	88, 90, 95, 96, 97, 98, 99, 100, 
+	101, 103, 127, 135, 156, 160, 180, 195, 
+	215, 237, 240, 243, 246, 249, 252, 255, 
+	258, 261, 264, 270, 283, 288, 300, 305, 
+	323, 325, 347, 350, 353, 356, 359, 362, 
+	365, 368, 371, 374, 380, 393, 398, 410, 
+	415, 433, 436, 460, 469, 490, 495, 515, 
+	529, 549, 571, 575, 579, 583, 587, 591, 
+	595, 599, 603, 607, 614, 628, 634, 647, 
+	653, 671, 675, 699, 709, 730, 736, 740, 
+	763, 776, 797, 820, 841, 862, 882, 894, 
+	906, 924, 937, 950, 963, 976, 989, 1001, 
+	1004, 1007, 1010, 1017, 1020, 1023, 1045, 1047, 
+	1069, 1070, 1073, 1076, 1079, 1082, 1085, 1088, 
+	1091, 1094, 1097, 1103, 1116, 1121, 1133, 1138, 
+	1156, 1161, 1164, 1188, 1197, 1218, 1223, 1243, 
+	1258, 1279, 1302, 1305, 1329, 1338, 1359, 1362, 
+	1385, 1399, 1421, 1442, 1463, 1483, 1495, 1507, 
+	1525, 1538, 1551, 1564, 1577, 1590, 1602, 1604, 
+	1606, 1608, 1614, 1616, 1618, 1620, 1642, 1643, 
+	1646, 1649, 1652, 1655, 1658, 1661, 1664, 1667, 
+	1670, 1676, 1689, 1694, 1706, 1711, 1729, 1732, 
+	1756, 1765, 1786, 1791, 1811, 1826, 1846, 1868, 
+	1872, 1876, 1880, 1884, 1888, 1892, 1896, 1900, 
+	1904, 1911, 1925, 1931, 1944, 1950, 1968, 1972, 
+	1996, 2006, 2027, 2033, 2037, 2060, 2074, 2095, 
+	2118, 2139, 2160, 2180, 2192, 2204, 2222, 2235, 
+	2248, 2261, 2274, 2287, 2299, 2302, 2305, 2308, 
+	2315, 2318, 2321, 2343, 2345, 2349, 2353, 2357, 
+	2361, 2365, 2369, 2373, 2377, 2381, 2388, 2402, 
+	2408, 2421, 2427, 2445, 2451, 2455, 2479, 2489, 
+	2510, 2516, 2536, 2551, 2572, 2595, 2599, 2603, 
+	2607, 2611, 2615, 2619, 2623, 2627, 2631, 2638, 
+	2652, 2658, 2671, 2677, 2695, 2699, 2723, 2733, 
+	2754, 2774, 2788, 2810, 2814, 2837, 2858, 2879, 
+	2899, 2911, 2923, 2941, 2954, 2967, 2980, 2993, 
+	3006, 3018, 3021, 3024, 3027, 3034, 3037, 3040, 
+	3051, 3054, 3057, 3060, 3063, 3066, 3086, 3091, 
+	3111, 3132, 3153, 3174, 3193, 3214, 3221, 3228, 
+	3235, 3242, 3245, 3248, 3269, 3287, 3303, 3327, 
+	3340, 3353, 3359, 3377, 3392, 3416, 3419, 3442, 
+	3463, 3484, 3504, 3516, 3528, 3546, 3559, 3572, 
+	3585, 3598, 3611, 3623, 3625, 3627, 3629, 3635, 
+	3637, 3639, 3649, 3651, 3653, 3655, 3657, 3659, 
+	3679, 3683, 3703, 3724, 3736, 3758, 3772, 3796, 
+	3798, 3821, 3842, 3863, 3883, 3895, 3907, 3925, 
+	3938, 3951, 3964, 3977, 3990, 4002, 4003, 4004, 
+	4005, 4010, 4011, 4012, 4021, 4041, 4044, 4064, 
+	4085, 4098, 4111, 4124, 4126, 4128, 4130, 4132, 
+	4134, 4136, 4142, 4144, 4146, 4168, 4183, 4207, 
+	4210, 4233, 4254, 4275, 4295, 4307, 4319, 4337, 
+	4350, 4363, 4376, 4389, 4402, 4414, 4416, 4418, 
+	4420, 4426, 4428, 4430, 4440, 4442, 4444, 4446, 
+	4448, 4450, 4470, 4474, 4494, 4515, 4529, 4543, 
+	4557, 4560, 4563, 4566, 4569, 4572, 4575, 4582, 
+	4585, 4588, 4603, 4618, 4630, 4644, 4658, 4679, 
+	4702, 4723, 4744, 4764, 4776, 4788, 4806, 4819, 
+	4832, 4845, 4858, 4871, 4883, 4886, 4889, 4892, 
+	4899, 4902, 4905, 4916, 4919, 4922, 4925, 4928, 
+	4931, 4951, 4956, 4976, 4997, 5019, 5023, 5046, 
+	5067, 5088, 5107, 5128, 5135, 5142, 5149, 5156, 
+	5159, 5162, 5183, 5201, 5217, 5241, 5254, 5267, 
+	5273, 5291, 5306, 5330, 5333, 5356, 5377, 5398, 
+	5418, 5430, 5442, 5460, 5473, 5486, 5499, 5512, 
+	5525, 5537, 5539, 5541, 5543, 5549, 5551, 5553, 
+	5563, 5565, 5567, 5569, 5571, 5573, 5593, 5597, 
+	5617, 5638, 5650, 5662, 5667, 5685, 5696, 5708, 
+	5720, 5732, 5733, 5734, 5735, 5736, 5737, 5738, 
+	5743, 5744, 5745, 5758, 5771, 5784, 5786, 5788, 
+	5790, 5792, 5794, 5796, 5802, 5804, 5806, 5819, 
+	5825, 5843, 5855, 5868, 5881, 5894, 5896, 5898, 
+	5900, 5902, 5904, 5906, 5912, 5914, 5916, 5930, 
+	5944, 5958, 5961, 5964, 5967, 5970, 5973, 5976, 
+	5983, 5986, 5989, 6004, 6019, 6031, 6045, 6059, 
+	6070, 6073, 6076, 6079, 6082, 6085, 6105, 6110, 
+	6130, 6151, 6173, 6194, 6215, 6234, 6255, 6262, 
+	6269, 6276, 6283, 6286, 6289, 6310, 6328, 6344, 
+	6368, 6381, 6403, 6416, 6422, 6440, 6455, 6479, 
+	6489, 6491, 6493, 6495, 6497, 6499, 6519, 6523, 
+	6543, 6564, 6576, 6589, 6602, 6615, 6617, 6619, 
+	6621, 6623, 6625, 6627, 6633, 6635, 6637, 6651, 
+	6665, 6679, 6682, 6685, 6688, 6691, 6694, 6697, 
+	6704, 6707, 6710, 6725, 6740, 6752, 6766, 6780, 
+	6801, 6824, 6845, 6868, 6890, 6911, 6932, 6951, 
+	6972, 6978, 6984, 6990, 6996, 6998, 7000, 7021, 
+	7035, 7049, 7060, 7073, 7086, 7107, 7128, 7147, 
+	7168, 7174, 7180, 7186, 7192, 7194, 7196, 7217, 
+	7238, 7261, 7283, 7304, 7325, 7344, 7365, 7371, 
+	7377, 7383, 7389, 7391, 7393, 7414, 7428, 7442, 
+	7453, 7466, 7479, 7490, 7493, 7496, 7499, 7502, 
+	7505, 7525, 7530, 7550, 7571, 7593, 7614, 7635, 
+	7654, 7675, 7682, 7689, 7696, 7703, 7706, 7709, 
+	7730, 7748, 7764, 7788, 7801, 7823, 7845, 7859, 
+	7873, 7887, 7890, 7893, 7896, 7899, 7902, 7905, 
+	7912, 7915, 7918, 7933, 7948, 7960, 7974, 7988, 
+	8010, 8031, 8052, 8071, 8092, 8098, 8104, 8110, 
+	8116, 8118, 8120, 8141, 8155, 8169, 8180, 8193, 
+	8206, 8220, 8234, 8245, 8258, 8271, 8292, 8315, 
+	8337, 8358, 8379, 8398, 8419, 8424, 8429, 8434, 
+	8439, 8440, 8441, 8462, 8475, 8488, 8498, 8510, 
+	8522, 8523, 8529, 8550, 8573, 8581, 8602, 8623, 
+	8646, 8653, 8674, 8697, 8718, 8741, 8748, 8762, 
+	8771, 8792, 8815, 8823, 8844, 8865, 8888, 8895, 
+	8909, 8918, 8939, 8962, 8970, 8991, 9012, 9035, 
+	9042, 9056, 9065, 9086, 9099, 9107, 9128, 9149, 
+	9162, 9170, 9191, 9214, 9222, 9243, 9257, 9266, 
+	9287, 9300, 9308, 9321, 9329, 9350, 9362
+};
+
+static readonly char[] _selector_trans_keys =  new char [] {
+	'\u0020', '\u002d', '\u0037', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u0031', '\u0037', '\u005c', '\u0000', '\u0031', 
+	'\u0020', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002c', '\u002e', '\u002f', '\u0020', '\u003a', '\u0009', '\u000d', '\u0020', 
+	'\u0022', '\u0027', '\u002b', '\u002d', '\u0037', '\u005c', '\u0075', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0022', '\u0020', '\u0021', '\u0022', '\u0027', '\u002b', '\u002c', 
+	'\u002d', '\u002f', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0049', '\u0069', '\u004d', '\u006d', '\u0050', '\u0070', '\u004f', '\u006f', 
+	'\u0052', '\u0072', '\u0054', '\u0074', '\u0041', '\u0061', '\u004e', '\u006e', 
+	'\u0054', '\u0074', '\u0020', '\u003b', '\u007d', '\u0009', '\u000d', '\u002d', 
+	'\u003e', '\u0021', '\u002d', '\u002d', '\u0027', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u002b', '\u002d', '\u002e', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u002c', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0037', 
+	'\u005c', '\u0000', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0029', '\u0009', '\u000d', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u000a', '\u0022', '\u0027', '\u0028', 
+	'\u005c', '\u0075', '\u007d', '\u000c', '\u000d', '\u0030', '\u0039', '\u0041', 
+	'\u0046', '\u0061', '\u0066', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0022', '\u0049', '\u0069', 
+	'\u0022', '\u004d', '\u006d', '\u0022', '\u0050', '\u0070', '\u0022', '\u004f', 
+	'\u006f', '\u0022', '\u0052', '\u0072', '\u0022', '\u0054', '\u0074', '\u0022', 
+	'\u0041', '\u0061', '\u0022', '\u004e', '\u006e', '\u0022', '\u0054', '\u0074', 
+	'\u0020', '\u0022', '\u003b', '\u007d', '\u0009', '\u000d', '\u0020', '\u0022', 
+	'\u002d', '\u0037', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u0031', '\u0022', '\u0037', '\u005c', '\u0000', '\u0031', 
+	'\u0020', '\u0022', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u003a', '\u0009', 
+	'\u000d', '\u0020', '\u0022', '\u0027', '\u002b', '\u002d', '\u0037', '\u005c', 
+	'\u0075', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0022', '\u0027', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0027', '\u0049', '\u0069', '\u0027', '\u004d', 
+	'\u006d', '\u0027', '\u0050', '\u0070', '\u0027', '\u004f', '\u006f', '\u0027', 
+	'\u0052', '\u0072', '\u0027', '\u0054', '\u0074', '\u0027', '\u0041', '\u0061', 
+	'\u0027', '\u004e', '\u006e', '\u0027', '\u0054', '\u0074', '\u0020', '\u0027', 
+	'\u003b', '\u007d', '\u0009', '\u000d', '\u0020', '\u0027', '\u002d', '\u0037', 
+	'\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u0031', '\u0027', '\u0037', '\u005c', '\u0000', '\u0031', '\u0020', '\u0027', 
+	'\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', 
+	'\u002e', '\u002f', '\u0020', '\u0027', '\u003a', '\u0009', '\u000d', '\u0020', 
+	'\u0022', '\u0027', '\u002b', '\u002d', '\u0037', '\u005c', '\u0075', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0027', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', 
+	'\u0027', '\u002b', '\u002d', '\u002e', '\u0037', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u002c', '\u002f', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0027', '\u0037', '\u005c', '\u0000', 
+	'\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0027', '\u0029', '\u0009', '\u000d', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u000a', '\u0022', '\u0028', '\u005c', '\u0075', 
+	'\u007d', '\u000c', '\u000d', '\u0030', '\u0039', '\u0041', '\u0046', '\u0061', 
+	'\u0066', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0022', '\u0027', '\u0049', '\u0069', '\u0022', 
+	'\u0027', '\u004d', '\u006d', '\u0022', '\u0027', '\u0050', '\u0070', '\u0022', 
+	'\u0027', '\u004f', '\u006f', '\u0022', '\u0027', '\u0052', '\u0072', '\u0022', 
+	'\u0027', '\u0054', '\u0074', '\u0022', '\u0027', '\u0041', '\u0061', '\u0022', 
+	'\u0027', '\u004e', '\u006e', '\u0022', '\u0027', '\u0054', '\u0074', '\u0020', 
+	'\u0022', '\u0027', '\u003b', '\u007d', '\u0009', '\u000d', '\u0020', '\u0022', 
+	'\u0027', '\u002d', '\u0037', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u0031', '\u0022', '\u0027', '\u0037', '\u005c', 
+	'\u0000', '\u0031', '\u0020', '\u0022', '\u0027', '\u003a', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', 
+	'\u0022', '\u0027', '\u003a', '\u0009', '\u000d', '\u0020', '\u0022', '\u0027', 
+	'\u002b', '\u002d', '\u0037', '\u005c', '\u0075', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0022', 
+	'\u0027', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', 
+	'\u002b', '\u002d', '\u002e', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u002c', '\u002f', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0022', '\u0027', '\u0037', '\u005c', '\u0000', 
+	'\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u0029', '\u0009', '\u000d', 
+	'\u0022', '\u0027', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', 
+	'\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u000a', '\u0028', '\u005c', '\u0075', '\u007d', 
+	'\u000c', '\u000d', '\u0030', '\u0039', '\u0041', '\u0046', '\u0061', '\u0066', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u0029', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0029', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0072', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u006c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', 
+	'\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0030', '\u0039', 
+	'\u0041', '\u0046', '\u0061', '\u0066', '\u0020', '\u0022', '\u0027', '\u0028', 
+	'\u0029', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u0031', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', 
+	'\u0027', '\u0028', '\u0029', '\u002c', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u0036', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', 
+	'\u0028', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u001f', '\u000d', '\u0022', '\u0027', '\u000a', '\u0022', '\u0027', '\u0022', 
+	'\u0027', '\u007c', '\u0020', '\u0022', '\u0027', '\u0009', '\u000a', '\u000c', 
+	'\u000d', '\u0022', '\u0027', '\u0029', '\u0022', '\u0027', '\u003f', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0022', '\u0027', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0022', '\u0022', '\u0049', 
+	'\u0069', '\u0022', '\u004d', '\u006d', '\u0022', '\u0050', '\u0070', '\u0022', 
+	'\u004f', '\u006f', '\u0022', '\u0052', '\u0072', '\u0022', '\u0054', '\u0074', 
+	'\u0022', '\u0041', '\u0061', '\u0022', '\u004e', '\u006e', '\u0022', '\u0054', 
+	'\u0074', '\u0020', '\u0022', '\u003b', '\u007d', '\u0009', '\u000d', '\u0020', 
+	'\u0022', '\u002d', '\u0037', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u0031', '\u0022', '\u0037', '\u005c', '\u0000', 
+	'\u0031', '\u0020', '\u0022', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u003a', 
+	'\u0009', '\u000d', '\u0020', '\u0022', '\u0027', '\u002b', '\u002d', '\u0037', 
+	'\u005c', '\u0075', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0022', '\u0029', '\u0009', 
+	'\u000d', '\u0022', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', 
+	'\u0027', '\u002b', '\u002d', '\u002e', '\u0037', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u002c', '\u002f', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0022', '\u0037', '\u005c', '\u0000', 
+	'\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0022', '\u0029', '\u0009', '\u000d', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u000a', '\u0022', '\u0027', '\u0028', '\u005c', 
+	'\u0075', '\u007d', '\u000c', '\u000d', '\u0030', '\u0039', '\u0041', '\u0046', 
+	'\u0061', '\u0066', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0029', '\u002b', '\u002c', '\u002d', '\u002f', 
+	'\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0022', '\u0030', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u002b', '\u002d', 
+	'\u002e', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u002c', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0022', '\u0037', '\u005c', '\u0000', '\u002f', '\u0030', '\u0031', 
+	'\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0022', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u002b', 
+	'\u002c', '\u002d', '\u002f', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u000a', '\u0027', '\u0028', '\u005c', '\u0075', '\u007d', '\u000c', 
+	'\u000d', '\u0030', '\u0039', '\u0041', '\u0046', '\u0061', '\u0066', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007b', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0072', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u006c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', 
+	'\u0022', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u001f', '\u0027', '\u0028', '\u0020', '\u0022', '\u0029', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0027', '\u0028', '\u0030', 
+	'\u0039', '\u0041', '\u0046', '\u0061', '\u0066', '\u0020', '\u0022', '\u0029', 
+	'\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0027', '\u0028', '\u0020', '\u0022', '\u0029', '\u0031', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0027', '\u0028', '\u0020', 
+	'\u0022', '\u0029', '\u002c', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u001f', '\u0027', '\u0028', '\u0020', '\u0022', '\u0029', '\u0036', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0027', 
+	'\u0028', '\u0020', '\u0022', '\u0029', '\u005c', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u001f', '\u0027', '\u0028', '\u0020', '\u0022', 
+	'\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u001f', '\u000d', '\u0022', '\u000a', '\u0022', '\u0022', '\u007c', 
+	'\u0020', '\u0022', '\u0009', '\u000a', '\u000c', '\u000d', '\u0022', '\u0029', 
+	'\u0022', '\u003f', '\u0022', '\u0027', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0031', 
+	'\u0032', '\u0039', '\u0027', '\u0027', '\u0049', '\u0069', '\u0027', '\u004d', 
+	'\u006d', '\u0027', '\u0050', '\u0070', '\u0027', '\u004f', '\u006f', '\u0027', 
+	'\u0052', '\u0072', '\u0027', '\u0054', '\u0074', '\u0027', '\u0041', '\u0061', 
+	'\u0027', '\u004e', '\u006e', '\u0027', '\u0054', '\u0074', '\u0020', '\u0027', 
+	'\u003b', '\u007d', '\u0009', '\u000d', '\u0020', '\u0027', '\u002d', '\u0037', 
+	'\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u0031', '\u0027', '\u0037', '\u005c', '\u0000', '\u0031', '\u0020', '\u0027', 
+	'\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', 
+	'\u002e', '\u002f', '\u0020', '\u0027', '\u003a', '\u0009', '\u000d', '\u0020', 
+	'\u0022', '\u0027', '\u002b', '\u002d', '\u0037', '\u005c', '\u0075', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0027', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', 
+	'\u0027', '\u002b', '\u002d', '\u002e', '\u0037', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u002c', '\u002f', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0027', '\u0037', '\u005c', '\u0000', 
+	'\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0027', '\u0029', '\u0009', '\u000d', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u000a', '\u0022', '\u0027', '\u0028', '\u005c', 
+	'\u0075', '\u007d', '\u000c', '\u000d', '\u0030', '\u0039', '\u0041', '\u0046', 
+	'\u0061', '\u0066', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0022', '\u0027', '\u0049', '\u0069', 
+	'\u0022', '\u0027', '\u004d', '\u006d', '\u0022', '\u0027', '\u0050', '\u0070', 
+	'\u0022', '\u0027', '\u004f', '\u006f', '\u0022', '\u0027', '\u0052', '\u0072', 
+	'\u0022', '\u0027', '\u0054', '\u0074', '\u0022', '\u0027', '\u0041', '\u0061', 
+	'\u0022', '\u0027', '\u004e', '\u006e', '\u0022', '\u0027', '\u0054', '\u0074', 
+	'\u0020', '\u0022', '\u0027', '\u003b', '\u007d', '\u0009', '\u000d', '\u0020', 
+	'\u0022', '\u0027', '\u002d', '\u0037', '\u003b', '\u005c', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u0031', '\u0022', '\u0027', '\u0037', 
+	'\u005c', '\u0000', '\u0031', '\u0020', '\u0022', '\u0027', '\u003a', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', 
+	'\u0020', '\u0022', '\u0027', '\u003a', '\u0009', '\u000d', '\u0020', '\u0022', 
+	'\u0027', '\u002b', '\u002d', '\u0037', '\u005c', '\u0075', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0022', '\u0027', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', 
+	'\u0027', '\u002b', '\u002d', '\u002e', '\u0037', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u002c', '\u002f', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0022', '\u0027', '\u0037', '\u005c', 
+	'\u0000', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u0029', '\u0009', 
+	'\u000d', '\u0022', '\u0027', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0025', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u000a', '\u0027', '\u0028', '\u005c', 
+	'\u0075', '\u007d', '\u000c', '\u000d', '\u0030', '\u0039', '\u0041', '\u0046', 
+	'\u0061', '\u0066', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0029', '\u002b', '\u002c', '\u002d', '\u002f', 
+	'\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u0072', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u006c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u0028', 
+	'\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', 
+	'\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0030', '\u0039', '\u0041', '\u0046', '\u0061', '\u0066', '\u0020', '\u0022', 
+	'\u0027', '\u0028', '\u0029', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u0031', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u002c', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', 
+	'\u0028', '\u0029', '\u0036', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', 
+	'\u0022', '\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u001f', '\u000d', '\u0022', '\u0027', '\u000a', '\u0022', 
+	'\u0027', '\u0022', '\u0027', '\u007c', '\u0020', '\u0022', '\u0027', '\u0009', 
+	'\u000a', '\u000c', '\u000d', '\u0022', '\u0027', '\u0029', '\u0022', '\u0027', 
+	'\u003f', '\u0020', '\u0021', '\u0022', '\u0027', '\u002b', '\u002c', '\u002d', 
+	'\u002f', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0022', 
+	'\u0027', '\u0022', '\u0027', '\u0049', '\u0069', '\u0022', '\u0027', '\u004d', 
+	'\u006d', '\u0022', '\u0027', '\u0050', '\u0070', '\u0022', '\u0027', '\u004f', 
+	'\u006f', '\u0022', '\u0027', '\u0052', '\u0072', '\u0022', '\u0027', '\u0054', 
+	'\u0074', '\u0022', '\u0027', '\u0041', '\u0061', '\u0022', '\u0027', '\u004e', 
+	'\u006e', '\u0022', '\u0027', '\u0054', '\u0074', '\u0020', '\u0022', '\u0027', 
+	'\u003b', '\u007d', '\u0009', '\u000d', '\u0020', '\u0022', '\u0027', '\u002d', 
+	'\u0037', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u0031', '\u0022', '\u0027', '\u0037', '\u005c', '\u0000', '\u0031', 
+	'\u0020', '\u0022', '\u0027', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u0027', 
+	'\u003a', '\u0009', '\u000d', '\u0020', '\u0022', '\u0027', '\u002b', '\u002d', 
+	'\u0037', '\u005c', '\u0075', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0022', '\u0027', 
+	'\u0029', '\u0009', '\u000d', '\u0022', '\u0027', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u002b', '\u002d', '\u002e', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u002c', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0022', 
+	'\u0027', '\u0037', '\u005c', '\u0000', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0022', 
+	'\u0027', '\u0029', '\u0009', '\u000d', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', 
+	'\u000a', '\u0022', '\u0027', '\u0028', '\u005c', '\u0075', '\u007d', '\u000c', 
+	'\u000d', '\u0030', '\u0039', '\u0041', '\u0046', '\u0061', '\u0066', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u0029', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0029', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0022', '\u0027', '\u0049', '\u0069', '\u0022', 
+	'\u0027', '\u004d', '\u006d', '\u0022', '\u0027', '\u0050', '\u0070', '\u0022', 
+	'\u0027', '\u004f', '\u006f', '\u0022', '\u0027', '\u0052', '\u0072', '\u0022', 
+	'\u0027', '\u0054', '\u0074', '\u0022', '\u0027', '\u0041', '\u0061', '\u0022', 
+	'\u0027', '\u004e', '\u006e', '\u0022', '\u0027', '\u0054', '\u0074', '\u0020', 
+	'\u0022', '\u0027', '\u003b', '\u007d', '\u0009', '\u000d', '\u0020', '\u0022', 
+	'\u0027', '\u002d', '\u0037', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u0031', '\u0022', '\u0027', '\u0037', '\u005c', 
+	'\u0000', '\u0031', '\u0020', '\u0022', '\u0027', '\u003a', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', 
+	'\u0022', '\u0027', '\u003a', '\u0009', '\u000d', '\u0020', '\u0022', '\u0027', 
+	'\u002b', '\u002d', '\u0037', '\u005c', '\u0075', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0022', 
+	'\u0027', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', 
+	'\u002b', '\u002d', '\u002e', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u002c', '\u002f', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0022', '\u0027', '\u0037', '\u005c', '\u0000', 
+	'\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u000a', '\u0022', 
+	'\u0028', '\u005c', '\u0075', '\u007d', '\u000c', '\u000d', '\u0030', '\u0039', 
+	'\u0041', '\u0046', '\u0061', '\u0066', '\u0020', '\u0021', '\u0022', '\u0025', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', 
+	'\u007b', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0022', '\u0027', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0025', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0072', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u006c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', 
+	'\u0022', '\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0030', 
+	'\u0039', '\u0041', '\u0046', '\u0061', '\u0066', '\u0020', '\u0022', '\u0027', 
+	'\u0028', '\u0029', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u0031', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', 
+	'\u0022', '\u0027', '\u0028', '\u0029', '\u002c', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', 
+	'\u0029', '\u0036', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', 
+	'\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u001f', '\u000d', '\u0022', '\u0027', '\u000a', '\u0022', '\u0027', 
+	'\u0022', '\u0027', '\u007c', '\u0020', '\u0022', '\u0027', '\u0009', '\u000a', 
+	'\u000c', '\u000d', '\u0022', '\u0027', '\u0029', '\u0022', '\u0027', '\u003f', 
+	'\u0022', '\u0027', '\u002d', '\u0037', '\u005c', '\u0000', '\u002f', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0022', '\u0027', '\u003e', '\u0022', '\u0027', 
+	'\u002d', '\u0021', '\u0022', '\u0027', '\u0022', '\u0027', '\u002d', '\u0022', 
+	'\u0027', '\u002d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0022', '\u0027', 
+	'\u002d', '\u0049', '\u0069', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002d', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u003e', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u0031', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0022', 
+	'\u0027', '\u002b', '\u002d', '\u0036', '\u0037', '\u005c', '\u0075', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u000d', '\u0020', 
+	'\u0022', '\u0027', '\u0029', '\u0009', '\u000c', '\u000a', '\u0020', '\u0022', 
+	'\u0027', '\u0029', '\u0009', '\u000d', '\u0020', '\u0022', '\u0027', '\u0029', 
+	'\u007c', '\u0009', '\u000d', '\u0020', '\u0022', '\u0027', '\u0009', '\u000a', 
+	'\u000c', '\u000d', '\u0022', '\u0027', '\u0029', '\u0022', '\u0027', '\u003f', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007b', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', 
+	'\u002b', '\u002d', '\u0037', '\u005c', '\u0075', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', 
+	'\u0022', '\u0027', '\u002d', '\u0037', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u002b', '\u002d', '\u002e', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u002c', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u000a', 
+	'\u0022', '\u0027', '\u003a', '\u005c', '\u000c', '\u000d', '\u0030', '\u0039', 
+	'\u0041', '\u0046', '\u0061', '\u0066', '\u0020', '\u0027', '\u0029', '\u003a', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', 
+	'\u002f', '\u0020', '\u0027', '\u0029', '\u003a', '\u0009', '\u000d', '\u0020', 
+	'\u0022', '\u0027', '\u002b', '\u002d', '\u0037', '\u005c', '\u0075', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0020', '\u0027', '\u002d', '\u0037', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u002b', '\u002d', '\u002e', 
+	'\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u002c', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0027', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', 
+	'\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0031', 
+	'\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u0072', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u006c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', 
+	'\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', 
+	'\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u001f', '\u0030', '\u0039', '\u0041', '\u0046', 
+	'\u0061', '\u0066', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', 
+	'\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', 
+	'\u0022', '\u0027', '\u0028', '\u0029', '\u0031', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', 
+	'\u0029', '\u002c', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u0036', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', 
+	'\u0027', '\u0028', '\u0029', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u000d', 
+	'\u0027', '\u000a', '\u0027', '\u0027', '\u007c', '\u0020', '\u0027', '\u0009', 
+	'\u000a', '\u000c', '\u000d', '\u0027', '\u0029', '\u0027', '\u003f', '\u0027', 
+	'\u002d', '\u0037', '\u005c', '\u0000', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0027', '\u003e', '\u0027', '\u002d', '\u0021', '\u0027', '\u0027', 
+	'\u002d', '\u0027', '\u002d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0027', 
+	'\u002d', '\u0049', '\u0069', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002d', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u003e', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u000a', '\u0027', '\u003a', '\u005c', 
+	'\u000c', '\u000d', '\u0030', '\u0039', '\u0041', '\u0046', '\u0061', '\u0066', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', 
+	'\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u002d', 
+	'\u0037', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', 
+	'\u0027', '\u002b', '\u002d', '\u002e', '\u0037', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u002c', '\u002f', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0025', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0072', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u006c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', 
+	'\u0022', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u001f', '\u0027', '\u0028', '\u0020', '\u0022', '\u0029', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0027', '\u0028', '\u0030', 
+	'\u0039', '\u0041', '\u0046', '\u0061', '\u0066', '\u0020', '\u0022', '\u0029', 
+	'\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0027', '\u0028', '\u0020', '\u0022', '\u0029', '\u0031', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0027', '\u0028', '\u0020', 
+	'\u0022', '\u0029', '\u002c', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u001f', '\u0027', '\u0028', '\u0020', '\u0022', '\u0029', '\u0036', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0027', 
+	'\u0028', '\u0020', '\u0022', '\u0029', '\u005c', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u001f', '\u0027', '\u0028', '\u0020', '\u0022', 
+	'\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u001f', '\u000d', '\u000a', '\u007c', '\u0020', '\u0009', '\u000a', 
+	'\u000c', '\u000d', '\u0029', '\u003f', '\u002d', '\u0037', '\u005c', '\u0000', 
+	'\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', 
+	'\u0039', '\u002d', '\u0049', '\u0069', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002d', '\u002f', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u003e', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0027', '\u003a', 
+	'\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', 
+	'\u002e', '\u002f', '\u0020', '\u0027', '\u0031', '\u003a', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', 
+	'\u0027', '\u002c', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002b', '\u002e', '\u002f', '\u0027', '\u0036', '\u0027', '\u007d', 
+	'\u0027', '\u0028', '\u000d', '\u0027', '\u000a', '\u0027', '\u0027', '\u007c', 
+	'\u0020', '\u0027', '\u0009', '\u000a', '\u000c', '\u000d', '\u0027', '\u0029', 
+	'\u0027', '\u003f', '\u0020', '\u0021', '\u0022', '\u0027', '\u002b', '\u002c', 
+	'\u002d', '\u002f', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0020', '\u0022', '\u002d', '\u0037', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u002b', '\u002d', '\u002e', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u002c', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0022', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u002b', 
+	'\u002c', '\u002d', '\u002f', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u0072', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u006c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0022', '\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0029', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0027', '\u0028', '\u0020', 
+	'\u0022', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u001f', '\u0027', '\u0028', '\u0030', '\u0039', '\u0041', '\u0046', '\u0061', 
+	'\u0066', '\u0020', '\u0022', '\u0029', '\u005c', '\u007b', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u001f', '\u0027', '\u0028', '\u0020', '\u0022', 
+	'\u0029', '\u0031', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u001f', '\u0027', '\u0028', '\u0020', '\u0022', '\u0029', '\u002c', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0027', '\u0028', 
+	'\u0020', '\u0022', '\u0029', '\u0036', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u001f', '\u0027', '\u0028', '\u0020', '\u0022', '\u0029', 
+	'\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0027', '\u0028', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u000d', '\u0022', 
+	'\u000a', '\u0022', '\u0022', '\u007c', '\u0020', '\u0022', '\u0009', '\u000a', 
+	'\u000c', '\u000d', '\u0022', '\u0029', '\u0022', '\u003f', '\u0022', '\u002d', 
+	'\u0037', '\u005c', '\u0000', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0022', '\u003e', '\u0022', '\u002d', '\u0021', '\u0022', '\u0022', '\u002d', 
+	'\u0022', '\u002d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0022', '\u002d', 
+	'\u0049', '\u0069', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002d', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u003e', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u003a', '\u005c', 
+	'\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', 
+	'\u002f', '\u0020', '\u0022', '\u0027', '\u0031', '\u003a', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', 
+	'\u0022', '\u0027', '\u002c', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002b', '\u002e', '\u002f', '\u0022', '\u0027', '\u0036', 
+	'\u0022', '\u0027', '\u007d', '\u0022', '\u0027', '\u0028', '\u000d', '\u0022', 
+	'\u0027', '\u000a', '\u0022', '\u0027', '\u0022', '\u0027', '\u007c', '\u0020', 
+	'\u0022', '\u0027', '\u0009', '\u000a', '\u000c', '\u000d', '\u0022', '\u0027', 
+	'\u0029', '\u0022', '\u0027', '\u003f', '\u0020', '\u0022', '\u0027', '\u003a', 
+	'\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u0027', '\u002d', '\u0037', 
+	'\u003a', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u0031', '\u0020', '\u0022', '\u0027', '\u002d', '\u003a', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0020', '\u0022', 
+	'\u0027', '\u003a', '\u003e', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', 
+	'\u002e', '\u002f', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0029', '\u002b', '\u002c', '\u002d', '\u002f', 
+	'\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u0072', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u006c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u0028', 
+	'\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', 
+	'\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0030', '\u0039', '\u0041', '\u0046', '\u0061', '\u0066', '\u0020', '\u0022', 
+	'\u0027', '\u0028', '\u0029', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u0031', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u002c', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', 
+	'\u0028', '\u0029', '\u0036', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', 
+	'\u0022', '\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u001f', '\u000d', '\u0022', '\u0027', '\u000a', '\u0022', 
+	'\u0027', '\u0022', '\u0027', '\u007c', '\u0020', '\u0022', '\u0027', '\u0009', 
+	'\u000a', '\u000c', '\u000d', '\u0022', '\u0027', '\u0029', '\u0022', '\u0027', 
+	'\u003f', '\u0022', '\u0027', '\u002d', '\u0037', '\u005c', '\u0000', '\u002f', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0022', '\u0027', '\u003e', '\u0022', 
+	'\u0027', '\u002d', '\u0021', '\u0022', '\u0027', '\u0022', '\u0027', '\u002d', 
+	'\u0022', '\u0027', '\u002d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0022', 
+	'\u0027', '\u002d', '\u0049', '\u0069', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002d', '\u002f', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u003e', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u0075', '\u007b', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0022', '\u0027', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', 
+	'\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u0031', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', 
+	'\u0020', '\u0022', '\u0027', '\u002b', '\u002d', '\u0036', '\u0037', '\u005c', 
+	'\u0075', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', 
+	'\u000d', '\u0020', '\u0022', '\u0027', '\u0029', '\u0009', '\u000c', '\u000a', 
+	'\u0020', '\u0022', '\u0027', '\u0029', '\u0009', '\u000d', '\u0020', '\u0022', 
+	'\u0027', '\u0029', '\u007c', '\u0009', '\u000d', '\u0020', '\u0022', '\u0027', 
+	'\u0009', '\u000a', '\u000c', '\u000d', '\u0022', '\u0027', '\u0029', '\u0022', 
+	'\u0027', '\u003f', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007b', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0022', '\u0027', '\u002b', '\u002d', '\u0037', '\u005c', '\u0075', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0020', '\u0022', '\u0027', '\u002d', '\u0037', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u002b', '\u002d', 
+	'\u002e', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u002c', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u000a', '\u0022', '\u0027', '\u003a', '\u005c', '\u000c', '\u000d', 
+	'\u0030', '\u0039', '\u0041', '\u0046', '\u0061', '\u0066', '\u0020', '\u0027', 
+	'\u0029', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002c', '\u002e', '\u002f', '\u0020', '\u0027', '\u0029', '\u003a', '\u0009', 
+	'\u000d', '\u0020', '\u0022', '\u0027', '\u002b', '\u002d', '\u0037', '\u005c', 
+	'\u0075', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0020', '\u0027', '\u002d', '\u0037', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', 
+	'\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u002b', 
+	'\u002d', '\u002e', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u002c', '\u002f', '\u0030', '\u0031', 
+	'\u0032', '\u0039', '\u0027', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0025', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0072', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u006c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', 
+	'\u0027', '\u0028', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0030', '\u0039', 
+	'\u0041', '\u0046', '\u0061', '\u0066', '\u0020', '\u0022', '\u0027', '\u0028', 
+	'\u0029', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u0031', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', 
+	'\u0027', '\u0028', '\u0029', '\u002c', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', '\u0028', '\u0029', 
+	'\u0036', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u001f', 
+	'\u0020', '\u0022', '\u0027', '\u0028', '\u0029', '\u005c', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u001f', '\u0020', '\u0022', '\u0027', 
+	'\u0028', '\u0029', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u001f', '\u000d', '\u0027', '\u000a', '\u0027', '\u0027', '\u007c', '\u0020', 
+	'\u0027', '\u0009', '\u000a', '\u000c', '\u000d', '\u0027', '\u0029', '\u0027', 
+	'\u003f', '\u0027', '\u002d', '\u0037', '\u005c', '\u0000', '\u002f', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0027', '\u003e', '\u0027', '\u002d', '\u0021', 
+	'\u0027', '\u0027', '\u002d', '\u0027', '\u002d', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', 
+	'\u0039', '\u0027', '\u002d', '\u0049', '\u0069', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002d', '\u002f', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u003e', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u000a', '\u0027', 
+	'\u003a', '\u005c', '\u000c', '\u000d', '\u0030', '\u0039', '\u0041', '\u0046', 
+	'\u0061', '\u0066', '\u0020', '\u0029', '\u003a', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0029', 
+	'\u003a', '\u0009', '\u000d', '\u0020', '\u0022', '\u0027', '\u002b', '\u002d', 
+	'\u0037', '\u005c', '\u0075', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u000a', '\u003a', '\u005c', 
+	'\u000c', '\u000d', '\u0030', '\u0039', '\u0041', '\u0046', '\u0061', '\u0066', 
+	'\u0020', '\u003a', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0031', '\u003a', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', 
+	'\u0020', '\u002c', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002b', '\u002e', '\u002f', '\u0036', '\u007d', '\u0028', '\u000d', 
+	'\u000a', '\u007c', '\u0020', '\u0009', '\u000a', '\u000c', '\u000d', '\u0029', 
+	'\u003f', '\u0020', '\u0027', '\u003a', '\u005c', '\u007b', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0027', 
+	'\u0031', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002c', '\u002e', '\u002f', '\u0020', '\u0027', '\u002c', '\u003a', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002b', '\u002e', '\u002f', 
+	'\u0027', '\u0036', '\u0027', '\u007d', '\u0027', '\u0028', '\u000d', '\u0027', 
+	'\u000a', '\u0027', '\u0027', '\u007c', '\u0020', '\u0027', '\u0009', '\u000a', 
+	'\u000c', '\u000d', '\u0027', '\u0029', '\u0027', '\u003f', '\u0020', '\u0022', 
+	'\u0029', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u0029', '\u003a', '\u0009', 
+	'\u000d', '\u0020', '\u0022', '\u0027', '\u002b', '\u002d', '\u0037', '\u005c', 
+	'\u0075', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u000a', '\u0022', '\u003a', '\u005c', '\u000c', 
+	'\u000d', '\u0030', '\u0039', '\u0041', '\u0046', '\u0061', '\u0066', '\u0020', 
+	'\u0022', '\u003a', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u0031', '\u003a', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', 
+	'\u002f', '\u0020', '\u0022', '\u002c', '\u003a', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002b', '\u002e', '\u002f', '\u0022', '\u0036', 
+	'\u0022', '\u007d', '\u0022', '\u0028', '\u000d', '\u0022', '\u000a', '\u0022', 
+	'\u0022', '\u007c', '\u0020', '\u0022', '\u0009', '\u000a', '\u000c', '\u000d', 
+	'\u0022', '\u0029', '\u0022', '\u003f', '\u0020', '\u0022', '\u0027', '\u003a', 
+	'\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', 
+	'\u002e', '\u002f', '\u0020', '\u0022', '\u0027', '\u0031', '\u003a', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', 
+	'\u0020', '\u0022', '\u0027', '\u002c', '\u003a', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002b', '\u002e', '\u002f', '\u0022', '\u0027', 
+	'\u0036', '\u0022', '\u0027', '\u007d', '\u0022', '\u0027', '\u0028', '\u000d', 
+	'\u0022', '\u0027', '\u000a', '\u0022', '\u0027', '\u0022', '\u0027', '\u007c', 
+	'\u0020', '\u0022', '\u0027', '\u0009', '\u000a', '\u000c', '\u000d', '\u0022', 
+	'\u0027', '\u0029', '\u0022', '\u0027', '\u003f', '\u0020', '\u0022', '\u0027', 
+	'\u003a', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u0027', '\u002d', 
+	'\u0037', '\u003a', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u0031', '\u0020', '\u0022', '\u0027', '\u002d', '\u003a', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0020', 
+	'\u0022', '\u0027', '\u003a', '\u003e', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002c', '\u002e', '\u002f', '\u0022', '\u0027', '\u002d', '\u0037', '\u005c', 
+	'\u0000', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0022', '\u0027', 
+	'\u003e', '\u0022', '\u0027', '\u002d', '\u0021', '\u0022', '\u0027', '\u0022', 
+	'\u0027', '\u002d', '\u0022', '\u0027', '\u002d', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', 
+	'\u0039', '\u0022', '\u0027', '\u002d', '\u0049', '\u0069', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002d', '\u002f', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u003e', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007b', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u0031', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0022', '\u0027', '\u002b', '\u002d', '\u0036', '\u0037', '\u005c', '\u0075', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', 
+	'\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u000d', 
+	'\u0020', '\u0022', '\u0027', '\u0029', '\u0009', '\u000c', '\u000a', '\u0020', 
+	'\u0022', '\u0027', '\u0029', '\u0009', '\u000d', '\u0020', '\u0022', '\u0027', 
+	'\u0029', '\u007c', '\u0009', '\u000d', '\u0020', '\u0022', '\u0027', '\u0009', 
+	'\u000a', '\u000c', '\u000d', '\u0022', '\u0027', '\u0029', '\u0022', '\u0027', 
+	'\u003f', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u0075', '\u007b', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0022', 
+	'\u0027', '\u002b', '\u002d', '\u0037', '\u005c', '\u0075', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0020', '\u0022', '\u0027', '\u002d', '\u0037', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u002b', '\u002d', '\u002e', 
+	'\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u002c', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u000a', '\u0022', '\u0027', '\u003a', '\u005c', '\u000c', '\u000d', '\u0030', 
+	'\u0039', '\u0041', '\u0046', '\u0061', '\u0066', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0020', '\u0022', '\u0029', '\u003a', '\u005c', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', 
+	'\u0020', '\u0022', '\u0029', '\u003a', '\u0009', '\u000d', '\u0020', '\u0022', 
+	'\u0027', '\u002b', '\u002d', '\u0037', '\u005c', '\u0075', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0020', '\u0022', '\u002d', '\u0037', '\u005c', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u002b', '\u002d', '\u002e', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u002c', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0022', 
+	'\u002d', '\u0037', '\u005c', '\u0000', '\u002f', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0022', '\u003e', '\u0022', '\u002d', '\u0021', '\u0022', '\u0022', 
+	'\u002d', '\u0022', '\u002d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0022', 
+	'\u002d', '\u0049', '\u0069', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002d', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u003e', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u000a', '\u0022', '\u003a', '\u005c', 
+	'\u000c', '\u000d', '\u0030', '\u0039', '\u0041', '\u0046', '\u0061', '\u0066', 
+	'\u0020', '\u0022', '\u003a', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u0031', 
+	'\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', 
+	'\u002e', '\u002f', '\u0020', '\u0022', '\u002c', '\u003a', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002b', '\u002e', '\u002f', '\u0022', 
+	'\u0036', '\u0022', '\u007d', '\u0022', '\u0028', '\u000d', '\u0022', '\u000a', 
+	'\u0022', '\u0022', '\u007c', '\u0020', '\u0022', '\u0009', '\u000a', '\u000c', 
+	'\u000d', '\u0022', '\u0029', '\u0022', '\u003f', '\u0020', '\u0022', '\u0027', 
+	'\u003a', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u0027', '\u0031', '\u003a', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', 
+	'\u002f', '\u0020', '\u0022', '\u0027', '\u002c', '\u003a', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002b', '\u002e', '\u002f', '\u0022', 
+	'\u0027', '\u0036', '\u0022', '\u0027', '\u007d', '\u0022', '\u0027', '\u0028', 
+	'\u000d', '\u0022', '\u0027', '\u000a', '\u0022', '\u0027', '\u0022', '\u0027', 
+	'\u007c', '\u0020', '\u0022', '\u0027', '\u0009', '\u000a', '\u000c', '\u000d', 
+	'\u0022', '\u0027', '\u0029', '\u0022', '\u0027', '\u003f', '\u0020', '\u0022', 
+	'\u0027', '\u003a', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u0027', 
+	'\u002d', '\u0037', '\u003a', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u0031', '\u0020', '\u0022', '\u0027', '\u002d', 
+	'\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', 
+	'\u0020', '\u0022', '\u0027', '\u003a', '\u003e', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0028', '\u0029', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0029', '\u002b', '\u002c', 
+	'\u002d', '\u002f', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u0029', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0029', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', 
+	'\u007b', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u0031', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u002b', 
+	'\u002d', '\u0036', '\u0037', '\u005c', '\u0075', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u000d', '\u0020', '\u0027', '\u0029', 
+	'\u0009', '\u000c', '\u000a', '\u0020', '\u0027', '\u0029', '\u0009', '\u000d', 
+	'\u0020', '\u0027', '\u0029', '\u007c', '\u0009', '\u000d', '\u0020', '\u0027', 
+	'\u0009', '\u000a', '\u000c', '\u000d', '\u0027', '\u0029', '\u0027', '\u003f', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007b', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0027', '\u003a', 
+	'\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002c', '\u002e', '\u002f', '\u0020', '\u0027', '\u002d', '\u0037', '\u003a', 
+	'\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u0031', '\u0020', '\u0027', '\u002d', '\u003a', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002f', '\u0020', '\u0027', '\u003a', '\u003e', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', 
+	'\u002f', '\u0020', '\u0021', '\u0027', '\u003a', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u0031', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', 
+	'\u0020', '\u0022', '\u0027', '\u002b', '\u002d', '\u0036', '\u0037', '\u005c', 
+	'\u0075', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', 
+	'\u000d', '\u0020', '\u0022', '\u0029', '\u0009', '\u000c', '\u000a', '\u0020', 
+	'\u0022', '\u0029', '\u0009', '\u000d', '\u0020', '\u0022', '\u0029', '\u007c', 
+	'\u0009', '\u000d', '\u0020', '\u0022', '\u0009', '\u000a', '\u000c', '\u000d', 
+	'\u0022', '\u0029', '\u0022', '\u003f', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007b', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u0029', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0029', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', 
+	'\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', 
+	'\u0075', '\u007b', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002e', '\u002f', '\u0031', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', 
+	'\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', 
+	'\u002b', '\u002d', '\u0036', '\u0037', '\u005c', '\u0075', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0020', '\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u000d', '\u0020', '\u0022', 
+	'\u0029', '\u0009', '\u000c', '\u000a', '\u0020', '\u0022', '\u0029', '\u0009', 
+	'\u000d', '\u0020', '\u0022', '\u0029', '\u007c', '\u0009', '\u000d', '\u0020', 
+	'\u0022', '\u0009', '\u000a', '\u000c', '\u000d', '\u0022', '\u0029', '\u0022', 
+	'\u003f', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u0075', '\u007b', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0022', 
+	'\u003a', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u002d', '\u0037', 
+	'\u003a', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u0031', '\u0020', '\u0022', '\u002d', '\u003a', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0020', '\u0022', '\u003a', 
+	'\u003e', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', 
+	'\u002e', '\u002f', '\u0020', '\u0021', '\u0022', '\u003a', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0022', 
+	'\u0027', '\u002d', '\u0037', '\u005c', '\u0000', '\u002f', '\u0030', '\u0031', 
+	'\u0032', '\u0039', '\u0022', '\u0027', '\u003e', '\u0022', '\u0027', '\u002d', 
+	'\u0021', '\u0022', '\u0027', '\u0022', '\u0027', '\u002d', '\u0022', '\u0027', 
+	'\u002d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0022', '\u0027', '\u002d', 
+	'\u0049', '\u0069', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002d', '\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u003e', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007b', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u0031', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u002b', '\u002d', 
+	'\u0036', '\u0037', '\u005c', '\u0075', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u000d', '\u0020', '\u0022', '\u0027', '\u0029', 
+	'\u0009', '\u000c', '\u000a', '\u0020', '\u0022', '\u0027', '\u0029', '\u0009', 
+	'\u000d', '\u0020', '\u0022', '\u0027', '\u0029', '\u007c', '\u0009', '\u000d', 
+	'\u0020', '\u0022', '\u0027', '\u0009', '\u000a', '\u000c', '\u000d', '\u0022', 
+	'\u0027', '\u0029', '\u0022', '\u0027', '\u003f', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', 
+	'\u007b', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u002b', '\u002d', '\u0037', 
+	'\u005c', '\u0075', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0022', '\u0027', '\u002d', 
+	'\u0037', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', 
+	'\u0027', '\u002b', '\u002d', '\u002e', '\u0037', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u002c', '\u002f', 
+	'\u0030', '\u0031', '\u0032', '\u0039', '\u000a', '\u0022', '\u0027', '\u003a', 
+	'\u005c', '\u000c', '\u000d', '\u0030', '\u0039', '\u0041', '\u0046', '\u0061', 
+	'\u0066', '\u0020', '\u0021', '\u0022', '\u0027', '\u002b', '\u002c', '\u002d', 
+	'\u002f', '\u0037', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0022', '\u0027', 
+	'\u003a', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u0027', '\u0031', '\u003a', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', 
+	'\u002f', '\u0020', '\u0022', '\u0027', '\u002c', '\u003a', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002b', '\u002e', '\u002f', '\u0022', 
+	'\u0027', '\u0036', '\u0022', '\u0027', '\u007d', '\u0022', '\u0027', '\u0028', 
+	'\u000d', '\u0022', '\u0027', '\u000a', '\u0022', '\u0027', '\u0022', '\u0027', 
+	'\u007c', '\u0020', '\u0022', '\u0027', '\u0009', '\u000a', '\u000c', '\u000d', 
+	'\u0022', '\u0027', '\u0029', '\u0022', '\u0027', '\u003f', '\u0020', '\u0022', 
+	'\u0027', '\u003a', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u0027', 
+	'\u002d', '\u0037', '\u003a', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u0031', '\u0020', '\u0022', '\u0027', '\u002d', 
+	'\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', 
+	'\u0020', '\u0022', '\u0027', '\u003a', '\u003e', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0021', '\u0022', '\u0025', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', 
+	'\u007b', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002e', '\u002f', '\u0031', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u002b', 
+	'\u002d', '\u0036', '\u0037', '\u005c', '\u0075', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u000d', '\u0020', '\u0027', '\u0029', 
+	'\u0009', '\u000c', '\u000a', '\u0020', '\u0027', '\u0029', '\u0009', '\u000d', 
+	'\u0020', '\u0027', '\u0029', '\u007c', '\u0009', '\u000d', '\u0020', '\u0027', 
+	'\u0009', '\u000a', '\u000c', '\u000d', '\u0027', '\u0029', '\u0027', '\u003f', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007b', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0027', '\u003a', 
+	'\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002c', '\u002e', '\u002f', '\u0020', '\u0027', '\u002d', '\u0037', '\u003a', 
+	'\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u0031', '\u0020', '\u0027', '\u002d', '\u003a', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002f', '\u0020', '\u0027', '\u003a', '\u003e', 
+	'\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', 
+	'\u002f', '\u0020', '\u0021', '\u0027', '\u003a', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0022', 
+	'\u003a', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0022', '\u002d', '\u0037', 
+	'\u003a', '\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u0031', '\u0020', '\u0022', '\u002d', '\u003a', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0020', '\u0022', '\u003a', 
+	'\u003e', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', 
+	'\u002e', '\u002f', '\u0020', '\u0021', '\u0022', '\u003a', '\u005c', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u0029', '\u002b', '\u002c', '\u002e', 
+	'\u002f', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0029', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0020', '\u0021', '\u0022', '\u0025', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002e', '\u002f', '\u005c', '\u0075', '\u007b', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002a', '\u0030', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u0031', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u002b', '\u002d', 
+	'\u0036', '\u0037', '\u005c', '\u0075', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002f', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0025', '\u0027', '\u0028', '\u002b', '\u002c', '\u002e', '\u002f', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002a', '\u0030', '\u0039', '\u000d', '\u0020', '\u0029', '\u0009', '\u000c', 
+	'\u000a', '\u0020', '\u0029', '\u0009', '\u000d', '\u0020', '\u0029', '\u007c', 
+	'\u0009', '\u000d', '\u0020', '\u0009', '\u000a', '\u000c', '\u000d', '\u0029', 
+	'\u003f', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002e', '\u002f', '\u005c', '\u0075', '\u007b', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002a', '\u0030', '\u0039', '\u0020', '\u003a', 
+	'\u003b', '\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002c', '\u002e', '\u002f', '\u0020', '\u002d', '\u0037', '\u003a', '\u003b', 
+	'\u005c', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u0031', 
+	'\u0020', '\u002d', '\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002f', '\u0020', '\u003a', '\u003e', '\u005c', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002c', '\u002e', '\u002f', '\u0020', '\u0021', 
+	'\u003a', '\u005c', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002c', 
+	'\u002e', '\u002f', '\u007b', '\u0020', '\u002d', '\u003c', '\u007b', '\u0009', 
+	'\u000d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002d', '\u002f', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u003c', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0022', '\u0027', 
+	'\u002d', '\u003c', '\u007b', '\u0009', '\u000d', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002d', '\u002f', '\u003c', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002d', '\u002f', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', 
+	'\u003c', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0027', 
+	'\u002d', '\u003c', '\u007b', '\u0009', '\u000d', '\u0020', '\u0021', '\u0022', 
+	'\u0027', '\u0028', '\u002b', '\u002c', '\u002d', '\u002f', '\u003c', '\u005c', 
+	'\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', 
+	'\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u002b', '\u002c', 
+	'\u002d', '\u002f', '\u0037', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0031', '\u0032', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002d', '\u002f', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u003c', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0022', '\u002d', 
+	'\u003c', '\u007b', '\u0009', '\u000d', '\u0020', '\u0022', '\u0027', '\u002d', 
+	'\u003a', '\u003c', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002f', '\u0020', '\u0022', '\u0027', '\u002d', '\u003a', '\u003c', 
+	'\u007b', '\u0009', '\u000d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002d', '\u002f', '\u003c', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', 
+	'\u0037', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', 
+	'\u0022', '\u0027', '\u002d', '\u003c', '\u007b', '\u0009', '\u000d', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002d', '\u002f', 
+	'\u003c', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002e', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u0028', '\u002b', '\u002c', '\u002d', '\u002f', '\u003c', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', 
+	'\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u002b', '\u002c', '\u002d', 
+	'\u002f', '\u0037', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', 
+	'\u0020', '\u0027', '\u002d', '\u003c', '\u007b', '\u0009', '\u000d', '\u0020', 
+	'\u0022', '\u0027', '\u002d', '\u003a', '\u003c', '\u005c', '\u007b', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002f', '\u0020', '\u0022', '\u0027', 
+	'\u002d', '\u003a', '\u003c', '\u007b', '\u0009', '\u000d', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002d', '\u002f', '\u003c', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002e', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', '\u002b', 
+	'\u002c', '\u002d', '\u002f', '\u0037', '\u003c', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0031', 
+	'\u0032', '\u0039', '\u0020', '\u0022', '\u0027', '\u002d', '\u003c', '\u007b', 
+	'\u0009', '\u000d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002d', '\u002f', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002d', '\u002f', 
+	'\u003c', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002e', '\u0030', '\u0039', '\u0020', '\u0021', '\u0022', '\u0027', 
+	'\u002b', '\u002c', '\u002d', '\u002f', '\u0037', '\u003c', '\u005c', '\u0075', 
+	'\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', 
+	'\u0031', '\u0032', '\u0039', '\u0020', '\u0022', '\u002d', '\u003c', '\u007b', 
+	'\u0009', '\u000d', '\u0020', '\u0022', '\u0027', '\u002d', '\u003a', '\u003c', 
+	'\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002f', 
+	'\u0020', '\u0022', '\u0027', '\u002d', '\u003a', '\u003c', '\u007b', '\u0009', 
+	'\u000d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002d', '\u002f', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', '\u0027', 
+	'\u002d', '\u003a', '\u003c', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002f', '\u0020', '\u0027', '\u002d', '\u003a', '\u003c', 
+	'\u007b', '\u0009', '\u000d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', 
+	'\u002b', '\u002c', '\u002d', '\u002f', '\u003c', '\u005c', '\u0075', '\u007d', 
+	'\u0000', '\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', 
+	'\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002d', 
+	'\u002f', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', 
+	'\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', '\u0022', '\u002d', 
+	'\u003a', '\u003c', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002f', '\u0020', '\u0022', '\u002d', '\u003a', '\u003c', '\u007b', 
+	'\u0009', '\u000d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002d', '\u002f', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', 
+	'\u0021', '\u0022', '\u0027', '\u002b', '\u002c', '\u002d', '\u002f', '\u0037', 
+	'\u003c', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002e', '\u0030', '\u0031', '\u0032', '\u0039', '\u0020', '\u0022', 
+	'\u0027', '\u002d', '\u003c', '\u007b', '\u0009', '\u000d', '\u0020', '\u0021', 
+	'\u0022', '\u0027', '\u0028', '\u002b', '\u002c', '\u002d', '\u002f', '\u003c', 
+	'\u005c', '\u0075', '\u007d', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002e', '\u0030', '\u0039', '\u0020', '\u0022', '\u0027', '\u002d', '\u003a', 
+	'\u003c', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002f', '\u0020', '\u0022', '\u0027', '\u002d', '\u003a', '\u003c', '\u007b', 
+	'\u0009', '\u000d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', 
+	'\u002c', '\u002d', '\u002f', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', 
+	'\u0008', '\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', 
+	'\u0027', '\u002d', '\u003a', '\u003c', '\u005c', '\u007b', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002f', '\u0020', '\u0027', '\u002d', '\u003a', 
+	'\u003c', '\u007b', '\u0009', '\u000d', '\u0020', '\u0022', '\u002d', '\u003a', 
+	'\u003c', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', '\u000e', 
+	'\u002f', '\u0020', '\u0022', '\u002d', '\u003a', '\u003c', '\u007b', '\u0009', 
+	'\u000d', '\u0020', '\u0021', '\u0022', '\u0027', '\u0028', '\u002b', '\u002c', 
+	'\u002d', '\u002f', '\u003c', '\u005c', '\u0075', '\u007d', '\u0000', '\u0008', 
+	'\u0009', '\u000d', '\u000e', '\u002e', '\u0030', '\u0039', '\u0020', '\u002d', 
+	'\u003a', '\u003c', '\u005c', '\u007b', '\u0000', '\u0008', '\u0009', '\u000d', 
+	'\u000e', '\u002f', '\u0020', '\u002d', '\u003a', '\u003c', '\u007b', '\u0009', 
+	'\u000d', (char) 0
+};
+
+static readonly sbyte[] _selector_single_lengths =  new sbyte [] {
+	0, 6, 2, 3, 2, 8, 1, 12, 
+	2, 2, 2, 2, 2, 2, 2, 2, 
+	2, 3, 1, 1, 1, 1, 1, 1, 
+	0, 12, 2, 13, 2, 12, 7, 12, 
+	12, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 4, 7, 3, 4, 3, 8, 
+	2, 12, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 4, 7, 3, 4, 3, 
+	8, 1, 12, 3, 13, 3, 12, 6, 
+	12, 12, 4, 4, 4, 4, 4, 4, 
+	4, 4, 4, 5, 8, 4, 5, 4, 
+	8, 2, 12, 4, 13, 4, 2, 13, 
+	5, 13, 13, 13, 13, 12, 6, 6, 
+	6, 7, 7, 7, 7, 7, 6, 3, 
+	3, 3, 3, 3, 3, 12, 2, 12, 
+	1, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 4, 7, 3, 4, 3, 8, 
+	3, 1, 12, 3, 13, 3, 12, 7, 
+	13, 13, 1, 12, 3, 13, 1, 13, 
+	6, 14, 13, 13, 12, 6, 4, 4, 
+	5, 5, 5, 5, 5, 6, 2, 2, 
+	2, 2, 2, 2, 2, 12, 1, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	4, 7, 3, 4, 3, 8, 1, 12, 
+	3, 13, 3, 12, 7, 12, 12, 4, 
+	4, 4, 4, 4, 4, 4, 4, 4, 
+	5, 8, 4, 5, 4, 8, 2, 12, 
+	4, 13, 4, 2, 13, 6, 13, 13, 
+	13, 13, 12, 6, 6, 6, 7, 7, 
+	7, 7, 7, 6, 3, 3, 3, 3, 
+	3, 3, 12, 2, 4, 4, 4, 4, 
+	4, 4, 4, 4, 4, 5, 8, 4, 
+	5, 4, 8, 4, 2, 12, 4, 13, 
+	4, 12, 7, 13, 13, 4, 4, 4, 
+	4, 4, 4, 4, 4, 4, 5, 8, 
+	4, 5, 4, 8, 2, 12, 4, 13, 
+	12, 6, 14, 2, 13, 13, 13, 12, 
+	6, 6, 6, 7, 7, 7, 7, 7, 
+	6, 3, 3, 3, 3, 3, 3, 5, 
+	3, 3, 3, 3, 3, 12, 5, 12, 
+	13, 13, 13, 9, 13, 5, 5, 5, 
+	3, 3, 3, 13, 8, 6, 12, 5, 
+	5, 4, 8, 5, 12, 1, 13, 13, 
+	13, 12, 6, 6, 6, 7, 7, 7, 
+	7, 7, 6, 2, 2, 2, 2, 2, 
+	2, 4, 2, 2, 2, 2, 2, 12, 
+	4, 12, 13, 4, 12, 4, 12, 0, 
+	13, 13, 13, 12, 6, 4, 4, 5, 
+	5, 5, 5, 5, 6, 1, 1, 1, 
+	1, 1, 1, 3, 12, 3, 12, 13, 
+	5, 5, 5, 2, 2, 2, 2, 2, 
+	2, 2, 2, 2, 12, 5, 12, 1, 
+	13, 13, 13, 12, 6, 4, 4, 5, 
+	5, 5, 5, 5, 6, 2, 2, 2, 
+	2, 2, 2, 4, 2, 2, 2, 2, 
+	2, 12, 4, 12, 13, 6, 6, 6, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 7, 9, 6, 6, 6, 13, 13, 
+	13, 13, 12, 6, 6, 6, 7, 7, 
+	7, 7, 7, 6, 3, 3, 3, 3, 
+	3, 3, 5, 3, 3, 3, 3, 3, 
+	12, 5, 12, 13, 14, 2, 13, 13, 
+	13, 9, 13, 5, 5, 5, 3, 3, 
+	3, 13, 8, 6, 12, 5, 5, 4, 
+	8, 5, 12, 1, 13, 13, 13, 12, 
+	6, 6, 6, 7, 7, 7, 7, 7, 
+	6, 2, 2, 2, 2, 2, 2, 4, 
+	2, 2, 2, 2, 2, 12, 4, 12, 
+	13, 4, 4, 3, 8, 3, 4, 4, 
+	4, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 5, 5, 5, 2, 2, 2, 
+	2, 2, 2, 2, 2, 2, 5, 4, 
+	8, 4, 5, 5, 5, 2, 2, 2, 
+	2, 2, 2, 2, 2, 2, 6, 6, 
+	6, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 7, 9, 6, 6, 6, 5, 
+	3, 3, 3, 3, 3, 12, 5, 12, 
+	13, 14, 13, 13, 9, 13, 5, 5, 
+	5, 3, 3, 3, 13, 8, 6, 12, 
+	5, 12, 5, 4, 8, 5, 12, 4, 
+	2, 2, 2, 2, 2, 12, 4, 12, 
+	13, 4, 5, 5, 5, 2, 2, 2, 
+	2, 2, 2, 2, 2, 2, 6, 6, 
+	6, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 7, 9, 6, 6, 6, 13, 
+	13, 13, 13, 14, 13, 13, 9, 13, 
+	4, 4, 4, 2, 2, 2, 13, 6, 
+	8, 5, 5, 5, 13, 13, 9, 13, 
+	4, 4, 4, 2, 2, 2, 13, 13, 
+	13, 14, 13, 13, 9, 13, 4, 4, 
+	4, 2, 2, 2, 13, 6, 8, 5, 
+	5, 5, 5, 3, 3, 3, 3, 3, 
+	12, 5, 12, 13, 14, 13, 13, 9, 
+	13, 5, 5, 5, 3, 3, 3, 13, 
+	8, 6, 12, 5, 12, 12, 6, 6, 
+	6, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 7, 9, 6, 6, 6, 14, 
+	13, 13, 9, 13, 4, 4, 4, 2, 
+	2, 2, 13, 6, 8, 5, 5, 5, 
+	6, 8, 5, 5, 5, 13, 13, 14, 
+	13, 13, 9, 13, 3, 3, 3, 1, 
+	1, 1, 13, 5, 7, 4, 4, 4, 
+	1, 4, 13, 13, 6, 13, 13, 13, 
+	5, 13, 13, 13, 13, 5, 8, 7, 
+	13, 13, 6, 13, 13, 13, 5, 8, 
+	7, 13, 13, 6, 13, 13, 13, 5, 
+	8, 7, 13, 7, 6, 13, 13, 7, 
+	6, 13, 13, 6, 13, 8, 7, 13, 
+	7, 6, 7, 6, 13, 6, 5
+};
+
+static readonly sbyte[] _selector_range_lengths =  new sbyte [] {
+	0, 3, 1, 4, 1, 5, 0, 5, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 1, 0, 0, 0, 0, 0, 0, 
+	1, 6, 3, 4, 1, 4, 4, 4, 
+	5, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 1, 3, 1, 4, 1, 5, 
+	0, 5, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 1, 3, 1, 4, 1, 
+	5, 1, 6, 3, 4, 1, 4, 4, 
+	4, 5, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 1, 3, 1, 4, 1, 
+	5, 1, 6, 3, 4, 1, 1, 5, 
+	4, 4, 5, 4, 4, 4, 3, 3, 
+	6, 3, 3, 3, 3, 3, 3, 0, 
+	0, 0, 2, 0, 0, 5, 0, 5, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 1, 3, 1, 4, 1, 5, 
+	1, 1, 6, 3, 4, 1, 4, 4, 
+	4, 5, 1, 6, 3, 4, 1, 5, 
+	4, 4, 4, 4, 4, 3, 4, 7, 
+	4, 4, 4, 4, 4, 3, 0, 0, 
+	0, 2, 0, 0, 0, 5, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	1, 3, 1, 4, 1, 5, 1, 6, 
+	3, 4, 1, 4, 4, 4, 5, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	1, 3, 1, 4, 1, 5, 1, 6, 
+	3, 4, 1, 1, 5, 4, 4, 5, 
+	4, 4, 4, 3, 3, 6, 3, 3, 
+	3, 3, 3, 3, 0, 0, 0, 2, 
+	0, 0, 5, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 1, 3, 1, 
+	4, 1, 5, 1, 1, 6, 3, 4, 
+	1, 4, 4, 4, 5, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 1, 3, 
+	1, 4, 1, 5, 1, 6, 3, 4, 
+	4, 4, 4, 1, 5, 4, 4, 4, 
+	3, 3, 6, 3, 3, 3, 3, 3, 
+	3, 0, 0, 0, 2, 0, 0, 3, 
+	0, 0, 0, 0, 0, 4, 0, 4, 
+	4, 4, 4, 5, 4, 1, 1, 1, 
+	2, 0, 0, 4, 5, 5, 6, 4, 
+	4, 1, 5, 5, 6, 1, 5, 4, 
+	4, 4, 3, 3, 6, 3, 3, 3, 
+	3, 3, 3, 0, 0, 0, 2, 0, 
+	0, 3, 0, 0, 0, 0, 0, 4, 
+	0, 4, 4, 4, 5, 5, 6, 1, 
+	5, 4, 4, 4, 3, 4, 7, 4, 
+	4, 4, 4, 4, 3, 0, 0, 0, 
+	2, 0, 0, 3, 4, 0, 4, 4, 
+	4, 4, 4, 0, 0, 0, 0, 0, 
+	0, 2, 0, 0, 5, 5, 6, 1, 
+	5, 4, 4, 4, 3, 4, 7, 4, 
+	4, 4, 4, 4, 3, 0, 0, 0, 
+	2, 0, 0, 3, 0, 0, 0, 0, 
+	0, 4, 0, 4, 4, 4, 4, 4, 
+	0, 0, 0, 0, 0, 0, 2, 0, 
+	0, 4, 3, 3, 4, 4, 4, 5, 
+	4, 4, 4, 3, 3, 6, 3, 3, 
+	3, 3, 3, 3, 0, 0, 0, 2, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	4, 0, 4, 4, 4, 1, 5, 4, 
+	4, 5, 4, 1, 1, 1, 2, 0, 
+	0, 4, 5, 5, 6, 4, 4, 1, 
+	5, 5, 6, 1, 5, 4, 4, 4, 
+	3, 3, 6, 3, 3, 3, 3, 3, 
+	3, 0, 0, 0, 2, 0, 0, 3, 
+	0, 0, 0, 0, 0, 4, 0, 4, 
+	4, 4, 4, 1, 5, 4, 4, 4, 
+	4, 0, 0, 0, 0, 0, 0, 2, 
+	0, 0, 4, 4, 4, 0, 0, 0, 
+	0, 0, 0, 2, 0, 0, 4, 1, 
+	5, 4, 4, 4, 4, 0, 0, 0, 
+	0, 0, 0, 2, 0, 0, 4, 4, 
+	4, 0, 0, 0, 0, 0, 0, 2, 
+	0, 0, 4, 3, 3, 4, 4, 3, 
+	0, 0, 0, 0, 0, 4, 0, 4, 
+	4, 4, 4, 4, 5, 4, 1, 1, 
+	1, 2, 0, 0, 4, 5, 5, 6, 
+	4, 5, 4, 1, 5, 5, 6, 3, 
+	0, 0, 0, 0, 0, 4, 0, 4, 
+	4, 4, 4, 4, 4, 0, 0, 0, 
+	0, 0, 0, 2, 0, 0, 4, 4, 
+	4, 0, 0, 0, 0, 0, 0, 2, 
+	0, 0, 4, 3, 3, 4, 4, 4, 
+	5, 4, 5, 4, 4, 4, 5, 4, 
+	1, 1, 1, 2, 0, 0, 4, 4, 
+	3, 3, 4, 4, 4, 4, 5, 4, 
+	1, 1, 1, 2, 0, 0, 4, 4, 
+	5, 4, 4, 4, 5, 4, 1, 1, 
+	1, 2, 0, 0, 4, 4, 3, 3, 
+	4, 4, 3, 0, 0, 0, 0, 0, 
+	4, 0, 4, 4, 4, 4, 4, 5, 
+	4, 1, 1, 1, 2, 0, 0, 4, 
+	5, 5, 6, 4, 5, 5, 4, 4, 
+	4, 0, 0, 0, 0, 0, 0, 2, 
+	0, 0, 4, 3, 3, 4, 4, 4, 
+	4, 4, 5, 4, 1, 1, 1, 2, 
+	0, 0, 4, 4, 3, 3, 4, 4, 
+	4, 3, 3, 4, 4, 4, 5, 4, 
+	4, 4, 5, 4, 1, 1, 1, 2, 
+	0, 0, 4, 4, 3, 3, 4, 4, 
+	0, 1, 4, 5, 1, 4, 4, 5, 
+	1, 4, 5, 4, 5, 1, 3, 1, 
+	4, 5, 1, 4, 4, 5, 1, 3, 
+	1, 4, 5, 1, 4, 4, 5, 1, 
+	3, 1, 4, 3, 1, 4, 4, 3, 
+	1, 4, 5, 1, 4, 3, 1, 4, 
+	3, 1, 3, 1, 4, 3, 1
+};
+
+static readonly short[] _selector_index_offsets =  new short [] {
+	0, 0, 10, 14, 22, 26, 40, 42, 
+	60, 63, 66, 69, 72, 75, 78, 81, 
+	84, 87, 92, 94, 96, 98, 100, 102, 
+	104, 106, 125, 131, 149, 153, 170, 182, 
+	199, 217, 221, 225, 229, 233, 237, 241, 
+	245, 249, 253, 259, 270, 275, 284, 289, 
+	303, 306, 324, 328, 332, 336, 340, 344, 
+	348, 352, 356, 360, 366, 377, 382, 391, 
+	396, 410, 413, 432, 439, 457, 462, 479, 
+	490, 507, 525, 530, 535, 540, 545, 550, 
+	555, 560, 565, 570, 577, 589, 595, 605, 
+	611, 625, 629, 648, 656, 674, 680, 684, 
+	703, 713, 731, 750, 768, 786, 803, 813, 
+	823, 836, 847, 858, 869, 880, 891, 901, 
+	905, 909, 913, 919, 923, 927, 945, 948, 
+	966, 968, 972, 976, 980, 984, 988, 992, 
+	996, 1000, 1004, 1010, 1021, 1026, 1035, 1040, 
+	1054, 1059, 1062, 1081, 1088, 1106, 1111, 1128, 
+	1140, 1158, 1177, 1180, 1199, 1206, 1224, 1227, 
+	1246, 1257, 1276, 1294, 1312, 1329, 1339, 1348, 
+	1360, 1370, 1380, 1390, 1400, 1410, 1420, 1423, 
+	1426, 1429, 1434, 1437, 1440, 1443, 1461, 1463, 
+	1467, 1471, 1475, 1479, 1483, 1487, 1491, 1495, 
+	1499, 1505, 1516, 1521, 1530, 1535, 1549, 1552, 
+	1571, 1578, 1596, 1601, 1618, 1630, 1647, 1665, 
+	1670, 1675, 1680, 1685, 1690, 1695, 1700, 1705, 
+	1710, 1717, 1729, 1735, 1745, 1751, 1765, 1769, 
+	1788, 1796, 1814, 1820, 1824, 1843, 1854, 1872, 
+	1891, 1909, 1927, 1944, 1954, 1964, 1977, 1988, 
+	1999, 2010, 2021, 2032, 2042, 2046, 2050, 2054, 
+	2060, 2064, 2068, 2086, 2089, 2094, 2099, 2104, 
+	2109, 2114, 2119, 2124, 2129, 2134, 2141, 2153, 
+	2159, 2169, 2175, 2189, 2195, 2199, 2218, 2226, 
+	2244, 2250, 2267, 2279, 2297, 2316, 2321, 2326, 
+	2331, 2336, 2341, 2346, 2351, 2356, 2361, 2368, 
+	2380, 2386, 2396, 2402, 2416, 2420, 2439, 2447, 
+	2465, 2482, 2493, 2512, 2516, 2535, 2553, 2571, 
+	2588, 2598, 2608, 2621, 2632, 2643, 2654, 2665, 
+	2676, 2686, 2690, 2694, 2698, 2704, 2708, 2712, 
+	2721, 2725, 2729, 2733, 2737, 2741, 2758, 2764, 
+	2781, 2799, 2817, 2835, 2850, 2868, 2875, 2882, 
+	2889, 2895, 2899, 2903, 2921, 2935, 2947, 2966, 
+	2976, 2986, 2992, 3006, 3017, 3036, 3039, 3058, 
+	3076, 3094, 3111, 3121, 3131, 3144, 3155, 3166, 
+	3177, 3188, 3199, 3209, 3212, 3215, 3218, 3223, 
+	3226, 3229, 3237, 3240, 3243, 3246, 3249, 3252, 
+	3269, 3274, 3291, 3309, 3318, 3336, 3346, 3365, 
+	3367, 3386, 3404, 3422, 3439, 3449, 3458, 3470, 
+	3480, 3490, 3500, 3510, 3520, 3530, 3532, 3534, 
+	3536, 3540, 3542, 3544, 3551, 3568, 3572, 3589, 
+	3607, 3617, 3627, 3637, 3640, 3643, 3646, 3649, 
+	3652, 3655, 3660, 3663, 3666, 3684, 3695, 3714, 
+	3717, 3736, 3754, 3772, 3789, 3799, 3808, 3820, 
+	3830, 3840, 3850, 3860, 3870, 3880, 3883, 3886, 
+	3889, 3894, 3897, 3900, 3908, 3911, 3914, 3917, 
+	3920, 3923, 3940, 3945, 3962, 3980, 3991, 4002, 
+	4013, 4017, 4021, 4025, 4029, 4033, 4037, 4043, 
+	4047, 4051, 4063, 4076, 4086, 4097, 4108, 4126, 
+	4145, 4163, 4181, 4198, 4208, 4218, 4231, 4242, 
+	4253, 4264, 4275, 4286, 4296, 4300, 4304, 4308, 
+	4314, 4318, 4322, 4331, 4335, 4339, 4343, 4347, 
+	4351, 4368, 4374, 4391, 4409, 4428, 4432, 4451, 
+	4469, 4487, 4502, 4520, 4527, 4534, 4541, 4547, 
+	4551, 4555, 4573, 4587, 4599, 4618, 4628, 4638, 
+	4644, 4658, 4669, 4688, 4691, 4710, 4728, 4746, 
+	4763, 4773, 4783, 4796, 4807, 4818, 4829, 4840, 
+	4851, 4861, 4864, 4867, 4870, 4875, 4878, 4881, 
+	4889, 4892, 4895, 4898, 4901, 4904, 4921, 4926, 
+	4943, 4961, 4970, 4979, 4984, 4998, 5006, 5015, 
+	5024, 5033, 5035, 5037, 5039, 5041, 5043, 5045, 
+	5049, 5051, 5053, 5063, 5073, 5083, 5086, 5089, 
+	5092, 5095, 5098, 5101, 5106, 5109, 5112, 5122, 
+	5128, 5142, 5151, 5161, 5171, 5181, 5184, 5187, 
+	5190, 5193, 5196, 5199, 5204, 5207, 5210, 5221, 
+	5232, 5243, 5247, 5251, 5255, 5259, 5263, 5267, 
+	5273, 5277, 5281, 5293, 5306, 5316, 5327, 5338, 
+	5347, 5351, 5355, 5359, 5363, 5367, 5384, 5390, 
+	5407, 5425, 5444, 5462, 5480, 5495, 5513, 5520, 
+	5527, 5534, 5540, 5544, 5548, 5566, 5580, 5592, 
+	5611, 5621, 5639, 5649, 5655, 5669, 5680, 5699, 
+	5707, 5710, 5713, 5716, 5719, 5722, 5739, 5744, 
+	5761, 5779, 5788, 5798, 5808, 5818, 5821, 5824, 
+	5827, 5830, 5833, 5836, 5841, 5844, 5847, 5858, 
+	5869, 5880, 5884, 5888, 5892, 5896, 5900, 5904, 
+	5910, 5914, 5918, 5930, 5943, 5953, 5964, 5975, 
+	5993, 6012, 6030, 6049, 6068, 6086, 6104, 6119, 
+	6137, 6143, 6149, 6155, 6160, 6163, 6166, 6184, 
+	6195, 6207, 6216, 6226, 6236, 6254, 6272, 6287, 
+	6305, 6311, 6317, 6323, 6328, 6331, 6334, 6352, 
+	6370, 6389, 6408, 6426, 6444, 6459, 6477, 6483, 
+	6489, 6495, 6500, 6503, 6506, 6524, 6535, 6547, 
+	6556, 6566, 6576, 6585, 6589, 6593, 6597, 6601, 
+	6605, 6622, 6628, 6645, 6663, 6682, 6700, 6718, 
+	6733, 6751, 6758, 6765, 6772, 6778, 6782, 6786, 
+	6804, 6818, 6830, 6849, 6859, 6877, 6895, 6906, 
+	6917, 6928, 6932, 6936, 6940, 6944, 6948, 6952, 
+	6958, 6962, 6966, 6978, 6991, 7001, 7012, 7023, 
+	7042, 7060, 7078, 7093, 7111, 7117, 7123, 7129, 
+	7134, 7137, 7140, 7158, 7169, 7181, 7190, 7200, 
+	7210, 7221, 7233, 7242, 7252, 7262, 7280, 7299, 
+	7318, 7336, 7354, 7369, 7387, 7392, 7397, 7402, 
+	7406, 7408, 7410, 7428, 7438, 7449, 7457, 7466, 
+	7475, 7477, 7483, 7501, 7520, 7528, 7546, 7564, 
+	7583, 7590, 7608, 7627, 7645, 7664, 7671, 7683, 
+	7692, 7710, 7729, 7737, 7755, 7773, 7792, 7799, 
+	7811, 7820, 7838, 7857, 7865, 7883, 7901, 7920, 
+	7927, 7939, 7948, 7966, 7977, 7985, 8003, 8021, 
+	8032, 8040, 8058, 8077, 8085, 8103, 8115, 8124, 
+	8142, 8153, 8161, 8172, 8180, 8198, 8208
+};
+
+static readonly short[] _selector_trans_targs =  new short [] {
+	1, 2, 0, 811, 549, 869, 0, 1, 
+	0, 3, 0, 549, 0, 3, 4, 548, 
+	549, 0, 4, 0, 0, 3, 4, 5, 
+	4, 0, 5, 6, 23, 24, 26, 25, 
+	30, 377, 0, 5, 0, 25, 27, 29, 
+	7, 6, 7, 8, 6, 23, 24, 5, 
+	26, 5, 25, 30, 377, 825, 0, 7, 
+	0, 25, 27, 29, 9, 9, 0, 10, 
+	10, 0, 11, 11, 0, 12, 12, 0, 
+	13, 13, 0, 14, 14, 0, 15, 15, 
+	0, 16, 16, 0, 17, 17, 0, 17, 
+	1, 817, 17, 0, 19, 0, 817, 0, 
+	21, 0, 22, 0, 817, 0, 7, 23, 
+	25, 0, 7, 8, 6, 7, 23, 24, 
+	26, 375, 25, 30, 377, 825, 0, 7, 
+	0, 5, 25, 27, 29, 25, 30, 0, 
+	25, 27, 29, 7, 8, 6, 7, 23, 
+	28, 24, 5, 375, 5, 30, 377, 825, 
+	0, 7, 0, 27, 29, 28, 7, 28, 
+	0, 7, 8, 6, 23, 28, 24, 5, 
+	0, 5, 30, 377, 825, 0, 7, 0, 
+	27, 29, 7, 31, 70, 797, 30, 377, 
+	825, 7, 799, 810, 810, 29, 32, 33, 
+	32, 48, 136, 146, 47, 6, 47, 152, 
+	154, 845, 6, 32, 6, 149, 31, 32, 
+	33, 32, 48, 146, 47, 148, 47, 147, 
+	152, 154, 845, 6, 32, 6, 147, 149, 
+	31, 7, 34, 34, 6, 7, 35, 35, 
+	6, 7, 36, 36, 6, 7, 37, 37, 
+	6, 7, 38, 38, 6, 7, 39, 39, 
+	6, 7, 40, 40, 6, 7, 41, 41, 
+	6, 7, 42, 42, 6, 42, 7, 43, 
+	847, 42, 6, 43, 7, 44, 6, 792, 
+	649, 866, 6, 43, 6, 45, 7, 6, 
+	649, 6, 45, 46, 7, 636, 649, 6, 
+	46, 6, 6, 45, 46, 7, 47, 46, 
+	6, 47, 32, 48, 146, 148, 147, 152, 
+	154, 6, 47, 6, 147, 149, 31, 49, 
+	32, 48, 49, 50, 48, 49, 65, 64, 
+	67, 64, 66, 71, 343, 822, 23, 49, 
+	23, 66, 68, 70, 7, 51, 51, 23, 
+	7, 52, 52, 23, 7, 53, 53, 23, 
+	7, 54, 54, 23, 7, 55, 55, 23, 
+	7, 56, 56, 23, 7, 57, 57, 23, 
+	7, 58, 58, 23, 7, 59, 59, 23, 
+	59, 7, 60, 824, 59, 23, 60, 7, 
+	61, 23, 787, 371, 864, 23, 60, 23, 
+	62, 7, 23, 371, 23, 62, 63, 7, 
+	338, 371, 23, 63, 23, 23, 62, 63, 
+	7, 64, 63, 23, 64, 48, 49, 65, 
+	67, 66, 71, 343, 23, 64, 23, 66, 
+	68, 70, 7, 66, 23, 49, 50, 48, 
+	49, 49, 65, 67, 341, 66, 71, 343, 
+	822, 23, 49, 23, 64, 66, 68, 70, 
+	7, 66, 71, 23, 66, 68, 70, 49, 
+	50, 48, 49, 49, 69, 65, 64, 341, 
+	64, 71, 343, 822, 23, 49, 23, 68, 
+	70, 69, 7, 49, 69, 23, 49, 50, 
+	48, 49, 69, 65, 64, 23, 64, 71, 
+	343, 822, 23, 49, 23, 68, 70, 49, 
+	72, 679, 71, 343, 822, 49, 775, 786, 
+	786, 70, 73, 74, 73, 73, 93, 89, 
+	88, 48, 88, 96, 99, 857, 48, 73, 
+	48, 92, 72, 73, 74, 73, 73, 89, 
+	88, 91, 88, 90, 96, 99, 857, 48, 
+	73, 48, 90, 92, 72, 49, 32, 75, 
+	75, 48, 49, 32, 76, 76, 48, 49, 
+	32, 77, 77, 48, 49, 32, 78, 78, 
+	48, 49, 32, 79, 79, 48, 49, 32, 
+	80, 80, 48, 49, 32, 81, 81, 48, 
+	49, 32, 82, 82, 48, 49, 32, 83, 
+	83, 48, 83, 49, 32, 84, 859, 83, 
+	48, 84, 49, 32, 85, 48, 770, 755, 
+	861, 48, 84, 48, 86, 49, 32, 48, 
+	755, 48, 86, 87, 49, 32, 752, 755, 
+	48, 87, 48, 48, 86, 87, 49, 32, 
+	88, 87, 48, 88, 73, 73, 89, 91, 
+	90, 96, 99, 48, 88, 48, 90, 92, 
+	72, 49, 32, 90, 48, 73, 74, 73, 
+	73, 73, 89, 91, 94, 90, 96, 99, 
+	857, 48, 73, 48, 88, 90, 92, 72, 
+	49, 32, 90, 96, 48, 90, 92, 72, 
+	73, 74, 73, 73, 73, 93, 89, 88, 
+	94, 88, 96, 99, 857, 48, 73, 48, 
+	92, 72, 93, 49, 32, 73, 93, 48, 
+	49, 32, 95, 48, 73, 74, 73, 73, 
+	73, 89, 88, 91, 88, 90, 96, 99, 
+	857, 48, 73, 48, 90, 92, 72, 73, 
+	97, 96, 99, 857, 73, 740, 751, 751, 
+	72, 98, 74, 73, 73, 93, 73, 89, 
+	88, 48, 88, 96, 99, 857, 48, 98, 
+	48, 92, 72, 98, 74, 73, 73, 73, 
+	89, 88, 91, 88, 90, 96, 99, 857, 
+	48, 98, 48, 90, 92, 72, 73, 74, 
+	73, 73, 93, 89, 88, 48, 88, 96, 
+	100, 99, 857, 48, 73, 48, 92, 72, 
+	73, 74, 73, 73, 93, 89, 88, 48, 
+	88, 96, 101, 99, 857, 48, 73, 48, 
+	92, 72, 73, 74, 73, 73, 102, 89, 
+	88, 48, 88, 96, 99, 857, 48, 73, 
+	48, 92, 72, 102, 117, 198, 48, 73, 
+	104, 48, 102, 48, 103, 93, 49, 32, 
+	48, 73, 104, 48, 93, 48, 103, 93, 
+	49, 32, 48, 73, 104, 48, 93, 48, 
+	105, 105, 105, 103, 93, 49, 32, 48, 
+	73, 104, 106, 48, 93, 48, 103, 93, 
+	49, 32, 48, 73, 107, 104, 48, 93, 
+	48, 103, 93, 49, 32, 48, 73, 108, 
+	104, 48, 93, 48, 103, 93, 49, 32, 
+	48, 73, 109, 104, 48, 93, 48, 103, 
+	93, 49, 32, 48, 73, 104, 110, 48, 
+	93, 48, 103, 93, 49, 32, 111, 73, 
+	104, 48, 93, 48, 103, 112, 49, 32, 
+	48, 113, 49, 32, 48, 49, 32, 114, 
+	48, 115, 49, 32, 115, 115, 48, 49, 
+	32, 116, 48, 49, 32, 103, 48, 117, 
+	269, 93, 117, 284, 283, 286, 283, 285, 
+	289, 293, 818, 118, 117, 118, 285, 287, 
+	288, 69, 119, 118, 119, 121, 136, 118, 
+	137, 135, 139, 135, 138, 143, 417, 827, 
+	120, 119, 120, 138, 140, 142, 28, 120, 
+	28, 122, 122, 120, 28, 123, 123, 120, 
+	28, 124, 124, 120, 28, 125, 125, 120, 
+	28, 126, 126, 120, 28, 127, 127, 120, 
+	28, 128, 128, 120, 28, 129, 129, 120, 
+	28, 130, 130, 120, 130, 28, 131, 829, 
+	130, 120, 131, 28, 132, 120, 725, 577, 
+	855, 120, 131, 120, 133, 28, 120, 577, 
+	120, 133, 134, 28, 576, 577, 120, 134, 
+	120, 120, 133, 134, 28, 135, 134, 120, 
+	135, 136, 118, 137, 139, 138, 143, 417, 
+	120, 135, 120, 138, 140, 142, 136, 7, 
+	32, 136, 6, 28, 138, 120, 119, 121, 
+	136, 119, 118, 137, 139, 415, 138, 143, 
+	417, 827, 120, 119, 120, 135, 138, 140, 
+	142, 28, 138, 143, 120, 138, 140, 142, 
+	119, 121, 136, 119, 118, 141, 137, 135, 
+	415, 135, 143, 417, 827, 120, 119, 120, 
+	140, 142, 141, 28, 119, 141, 120, 119, 
+	121, 136, 118, 141, 137, 135, 120, 135, 
+	143, 417, 827, 120, 119, 120, 140, 142, 
+	119, 144, 288, 711, 143, 417, 827, 119, 
+	713, 724, 724, 142, 145, 33, 32, 48, 
+	136, 32, 146, 47, 6, 47, 152, 154, 
+	845, 6, 145, 6, 149, 31, 145, 33, 
+	32, 48, 32, 146, 47, 148, 47, 147, 
+	152, 154, 845, 6, 145, 6, 147, 149, 
+	31, 7, 147, 6, 32, 33, 32, 32, 
+	48, 146, 148, 150, 147, 152, 154, 845, 
+	6, 32, 6, 47, 147, 149, 31, 7, 
+	147, 152, 6, 147, 149, 31, 32, 33, 
+	32, 32, 48, 136, 146, 47, 150, 47, 
+	152, 154, 845, 6, 32, 6, 149, 31, 
+	7, 151, 6, 32, 33, 32, 32, 48, 
+	146, 47, 148, 47, 147, 152, 154, 845, 
+	6, 32, 6, 147, 149, 31, 32, 72, 
+	144, 152, 154, 845, 32, 153, 710, 710, 
+	31, 32, 33, 32, 32, 48, 136, 146, 
+	47, 150, 47, 152, 154, 700, 845, 6, 
+	32, 6, 149, 31, 32, 33, 32, 48, 
+	136, 146, 47, 6, 47, 152, 155, 154, 
+	845, 6, 32, 6, 149, 31, 32, 33, 
+	32, 48, 136, 146, 47, 6, 47, 152, 
+	156, 154, 845, 6, 32, 6, 149, 31, 
+	32, 33, 32, 48, 157, 146, 47, 6, 
+	47, 152, 154, 845, 6, 32, 6, 149, 
+	31, 157, 119, 172, 6, 32, 159, 6, 
+	157, 6, 158, 136, 7, 32, 159, 6, 
+	136, 6, 6, 158, 136, 7, 32, 159, 
+	6, 136, 6, 6, 160, 160, 160, 158, 
+	136, 7, 32, 159, 161, 6, 136, 6, 
+	6, 158, 136, 7, 32, 162, 159, 6, 
+	136, 6, 6, 158, 136, 7, 32, 163, 
+	159, 6, 136, 6, 6, 158, 136, 7, 
+	32, 164, 159, 6, 136, 6, 6, 158, 
+	136, 7, 32, 159, 165, 6, 136, 6, 
+	6, 158, 136, 7, 6, 166, 32, 159, 
+	6, 136, 6, 158, 167, 7, 6, 168, 
+	7, 6, 7, 169, 6, 170, 7, 170, 
+	170, 6, 7, 171, 6, 7, 158, 6, 
+	173, 136, 172, 173, 175, 172, 69, 190, 
+	189, 192, 189, 191, 196, 517, 836, 174, 
+	173, 174, 191, 193, 195, 28, 174, 28, 
+	176, 176, 174, 28, 177, 177, 174, 28, 
+	178, 178, 174, 28, 179, 179, 174, 28, 
+	180, 180, 174, 28, 181, 181, 174, 28, 
+	182, 182, 174, 28, 183, 183, 174, 28, 
+	184, 184, 174, 184, 28, 185, 838, 184, 
+	174, 185, 28, 186, 174, 695, 545, 851, 
+	174, 185, 174, 187, 28, 174, 545, 174, 
+	187, 188, 28, 512, 545, 174, 188, 174, 
+	174, 187, 188, 28, 189, 188, 174, 189, 
+	172, 69, 190, 192, 191, 196, 517, 174, 
+	189, 174, 191, 193, 195, 28, 191, 174, 
+	173, 175, 172, 173, 69, 190, 192, 515, 
+	191, 196, 517, 836, 174, 173, 174, 189, 
+	191, 193, 195, 28, 191, 196, 174, 191, 
+	193, 195, 173, 175, 172, 173, 69, 194, 
+	190, 189, 515, 189, 196, 517, 836, 174, 
+	173, 174, 193, 195, 194, 28, 173, 194, 
+	174, 173, 175, 172, 69, 194, 190, 189, 
+	174, 189, 196, 517, 836, 174, 173, 174, 
+	193, 195, 173, 197, 679, 681, 196, 517, 
+	836, 173, 683, 694, 694, 195, 198, 199, 
+	198, 93, 218, 214, 213, 172, 213, 221, 
+	224, 841, 172, 198, 172, 217, 197, 198, 
+	199, 198, 93, 214, 213, 216, 213, 215, 
+	221, 224, 841, 172, 198, 172, 215, 217, 
+	197, 173, 136, 200, 200, 172, 173, 136, 
+	201, 201, 172, 173, 136, 202, 202, 172, 
+	173, 136, 203, 203, 172, 173, 136, 204, 
+	204, 172, 173, 136, 205, 205, 172, 173, 
+	136, 206, 206, 172, 173, 136, 207, 207, 
+	172, 173, 136, 208, 208, 172, 208, 173, 
+	136, 209, 843, 208, 172, 209, 173, 136, 
+	210, 172, 674, 632, 848, 172, 209, 172, 
+	211, 173, 136, 172, 632, 172, 211, 212, 
+	173, 136, 629, 632, 172, 212, 172, 172, 
+	211, 212, 173, 136, 213, 212, 172, 213, 
+	198, 93, 214, 216, 215, 221, 224, 172, 
+	213, 172, 215, 217, 197, 173, 136, 215, 
+	172, 198, 199, 198, 198, 93, 214, 216, 
+	219, 215, 221, 224, 841, 172, 198, 172, 
+	213, 215, 217, 197, 173, 136, 215, 221, 
+	172, 215, 217, 197, 198, 199, 198, 198, 
+	93, 218, 214, 213, 219, 213, 221, 224, 
+	841, 172, 198, 172, 217, 197, 218, 173, 
+	136, 198, 218, 172, 173, 136, 220, 172, 
+	198, 199, 198, 198, 93, 214, 213, 216, 
+	213, 215, 221, 224, 841, 172, 198, 172, 
+	215, 217, 197, 198, 97, 222, 221, 224, 
+	841, 198, 617, 628, 628, 197, 223, 199, 
+	198, 93, 218, 198, 214, 213, 172, 213, 
+	221, 224, 841, 172, 223, 172, 217, 197, 
+	223, 199, 198, 93, 198, 214, 213, 216, 
+	213, 215, 221, 224, 841, 172, 223, 172, 
+	215, 217, 197, 198, 199, 198, 93, 218, 
+	214, 213, 172, 213, 221, 225, 224, 841, 
+	172, 198, 172, 217, 197, 198, 199, 198, 
+	93, 218, 214, 213, 172, 213, 221, 226, 
+	224, 841, 172, 198, 172, 217, 197, 198, 
+	199, 198, 93, 227, 214, 213, 172, 213, 
+	221, 224, 841, 172, 198, 172, 217, 197, 
+	227, 242, 218, 172, 198, 229, 172, 227, 
+	172, 228, 218, 173, 136, 172, 198, 229, 
+	172, 218, 172, 228, 218, 173, 136, 172, 
+	198, 229, 172, 218, 172, 230, 230, 230, 
+	228, 218, 173, 136, 172, 198, 229, 231, 
+	172, 218, 172, 228, 218, 173, 136, 172, 
+	198, 232, 229, 172, 218, 172, 228, 218, 
+	173, 136, 172, 198, 233, 229, 172, 218, 
+	172, 228, 218, 173, 136, 172, 198, 234, 
+	229, 172, 218, 172, 228, 218, 173, 136, 
+	172, 198, 229, 235, 172, 218, 172, 228, 
+	218, 173, 136, 236, 198, 229, 172, 218, 
+	172, 228, 237, 173, 136, 172, 238, 173, 
+	136, 172, 173, 136, 239, 172, 240, 173, 
+	136, 240, 240, 172, 173, 136, 241, 172, 
+	173, 136, 228, 172, 242, 244, 218, 259, 
+	260, 258, 262, 258, 261, 266, 464, 832, 
+	243, 242, 243, 261, 263, 265, 194, 141, 
+	243, 194, 141, 245, 245, 243, 194, 141, 
+	246, 246, 243, 194, 141, 247, 247, 243, 
+	194, 141, 248, 248, 243, 194, 141, 249, 
+	249, 243, 194, 141, 250, 250, 243, 194, 
+	141, 251, 251, 243, 194, 141, 252, 252, 
+	243, 194, 141, 253, 253, 243, 253, 194, 
+	141, 254, 834, 253, 243, 254, 194, 141, 
+	255, 243, 602, 509, 839, 243, 254, 243, 
+	256, 194, 141, 243, 509, 243, 256, 257, 
+	194, 141, 506, 509, 243, 257, 243, 243, 
+	256, 257, 194, 141, 258, 257, 243, 258, 
+	218, 259, 260, 262, 261, 266, 464, 243, 
+	258, 243, 261, 263, 265, 259, 69, 119, 
+	117, 259, 118, 194, 141, 261, 243, 242, 
+	244, 218, 242, 259, 260, 262, 493, 261, 
+	266, 464, 832, 243, 242, 243, 258, 261, 
+	263, 265, 194, 141, 261, 266, 243, 261, 
+	263, 265, 242, 244, 218, 242, 259, 264, 
+	260, 258, 493, 258, 266, 464, 832, 243, 
+	242, 243, 263, 265, 264, 194, 141, 242, 
+	264, 243, 242, 244, 218, 259, 264, 260, 
+	258, 243, 258, 266, 464, 832, 243, 242, 
+	243, 263, 265, 242, 222, 267, 462, 266, 
+	464, 832, 242, 492, 505, 505, 265, 268, 
+	269, 93, 117, 259, 117, 284, 283, 118, 
+	283, 289, 293, 818, 118, 268, 118, 287, 
+	288, 268, 269, 93, 117, 117, 284, 283, 
+	286, 283, 285, 289, 293, 818, 118, 268, 
+	118, 285, 287, 288, 69, 119, 270, 270, 
+	118, 69, 119, 271, 271, 118, 69, 119, 
+	272, 272, 118, 69, 119, 273, 273, 118, 
+	69, 119, 274, 274, 118, 69, 119, 275, 
+	275, 118, 69, 119, 276, 276, 118, 69, 
+	119, 277, 277, 118, 69, 119, 278, 278, 
+	118, 278, 69, 119, 279, 820, 278, 118, 
+	279, 69, 119, 280, 118, 457, 335, 830, 
+	118, 279, 118, 281, 69, 119, 118, 335, 
+	118, 281, 282, 69, 119, 332, 335, 118, 
+	282, 118, 118, 281, 282, 69, 119, 283, 
+	282, 118, 283, 93, 117, 284, 286, 285, 
+	289, 293, 118, 283, 118, 285, 287, 288, 
+	69, 119, 285, 118, 117, 269, 93, 117, 
+	117, 284, 286, 291, 285, 289, 293, 818, 
+	118, 117, 118, 283, 285, 287, 288, 69, 
+	119, 285, 289, 118, 285, 287, 288, 117, 
+	269, 93, 117, 117, 259, 284, 283, 291, 
+	283, 289, 293, 818, 118, 117, 118, 287, 
+	288, 117, 269, 93, 117, 259, 284, 283, 
+	118, 283, 289, 293, 818, 118, 117, 118, 
+	287, 288, 117, 97, 267, 289, 293, 818, 
+	117, 290, 331, 331, 288, 117, 269, 93, 
+	117, 117, 259, 284, 283, 291, 283, 289, 
+	293, 321, 818, 118, 117, 118, 287, 288, 
+	69, 119, 292, 118, 117, 269, 93, 117, 
+	117, 284, 283, 286, 283, 285, 289, 293, 
+	818, 118, 117, 118, 285, 287, 288, 117, 
+	269, 93, 117, 259, 284, 283, 118, 283, 
+	289, 294, 293, 818, 118, 117, 118, 287, 
+	288, 117, 269, 93, 117, 259, 284, 283, 
+	118, 283, 289, 295, 293, 818, 118, 117, 
+	118, 287, 288, 117, 269, 93, 117, 296, 
+	284, 283, 118, 283, 289, 293, 818, 118, 
+	117, 118, 287, 288, 296, 259, 242, 118, 
+	117, 298, 118, 296, 118, 297, 259, 69, 
+	119, 118, 117, 298, 118, 259, 118, 297, 
+	259, 69, 119, 118, 117, 298, 118, 259, 
+	118, 299, 299, 299, 297, 259, 69, 119, 
+	118, 117, 298, 300, 118, 259, 118, 297, 
+	259, 69, 119, 118, 117, 301, 298, 118, 
+	259, 118, 297, 259, 69, 119, 118, 117, 
+	302, 298, 118, 259, 118, 297, 259, 69, 
+	119, 118, 117, 303, 298, 118, 259, 118, 
+	297, 259, 69, 119, 118, 117, 298, 304, 
+	118, 259, 118, 297, 259, 69, 119, 305, 
+	117, 298, 118, 259, 118, 297, 306, 69, 
+	119, 118, 307, 69, 119, 118, 69, 119, 
+	308, 118, 309, 69, 119, 309, 309, 118, 
+	69, 119, 310, 118, 69, 119, 297, 118, 
+	69, 119, 312, 285, 289, 118, 285, 287, 
+	288, 69, 119, 820, 118, 69, 119, 312, 
+	118, 315, 69, 119, 118, 69, 119, 316, 
+	118, 69, 119, 820, 118, 117, 318, 93, 
+	117, 259, 284, 283, 118, 283, 289, 293, 
+	818, 118, 117, 118, 287, 288, 69, 119, 
+	316, 270, 270, 118, 117, 269, 93, 117, 
+	259, 284, 283, 320, 283, 289, 293, 818, 
+	118, 117, 118, 287, 288, 117, 269, 93, 
+	117, 259, 284, 283, 118, 283, 818, 289, 
+	293, 818, 118, 117, 118, 287, 288, 117, 
+	269, 93, 117, 259, 284, 283, 118, 283, 
+	322, 289, 293, 818, 118, 117, 118, 287, 
+	288, 117, 269, 93, 117, 117, 259, 284, 
+	323, 291, 283, 289, 293, 818, 118, 117, 
+	118, 287, 288, 283, 93, 117, 284, 286, 
+	324, 285, 289, 293, 118, 283, 118, 285, 
+	287, 288, 117, 269, 93, 117, 117, 259, 
+	284, 283, 291, 283, 289, 293, 821, 118, 
+	117, 118, 287, 288, 326, 259, 69, 119, 
+	117, 259, 118, 327, 259, 69, 119, 117, 
+	259, 118, 259, 69, 119, 117, 328, 259, 
+	118, 329, 69, 119, 329, 329, 118, 69, 
+	119, 330, 118, 69, 119, 288, 118, 117, 
+	269, 93, 117, 259, 284, 283, 118, 283, 
+	289, 293, 321, 818, 118, 117, 118, 287, 
+	288, 283, 93, 117, 284, 333, 334, 289, 
+	293, 118, 283, 118, 334, 287, 288, 282, 
+	69, 119, 281, 334, 289, 118, 282, 118, 
+	334, 287, 288, 117, 269, 93, 117, 117, 
+	284, 333, 291, 334, 289, 293, 818, 118, 
+	117, 118, 283, 334, 287, 288, 282, 336, 
+	412, 332, 335, 282, 445, 445, 445, 281, 
+	337, 7, 49, 338, 371, 23, 337, 23, 
+	23, 62, 337, 7, 49, 64, 337, 23, 
+	64, 48, 49, 65, 339, 340, 71, 343, 
+	23, 64, 23, 340, 68, 70, 63, 7, 
+	62, 340, 71, 23, 63, 23, 340, 68, 
+	70, 49, 50, 48, 49, 49, 65, 339, 
+	341, 340, 71, 343, 822, 23, 49, 23, 
+	64, 340, 68, 70, 7, 342, 23, 49, 
+	50, 48, 49, 49, 65, 64, 67, 64, 
+	66, 71, 343, 822, 23, 49, 23, 66, 
+	68, 70, 49, 50, 48, 49, 69, 65, 
+	64, 23, 64, 71, 344, 343, 822, 23, 
+	49, 23, 68, 70, 49, 50, 48, 49, 
+	69, 65, 64, 23, 64, 71, 345, 343, 
+	822, 23, 49, 23, 68, 70, 49, 50, 
+	48, 49, 346, 65, 64, 23, 64, 71, 
+	343, 822, 23, 49, 23, 68, 70, 346, 
+	118, 173, 23, 49, 348, 23, 346, 23, 
+	347, 69, 23, 7, 23, 49, 348, 23, 
+	69, 23, 347, 69, 23, 7, 23, 49, 
+	348, 23, 69, 23, 349, 349, 349, 347, 
+	69, 23, 7, 23, 49, 348, 350, 23, 
+	69, 23, 347, 69, 23, 7, 23, 49, 
+	351, 348, 23, 69, 23, 347, 69, 23, 
+	7, 23, 49, 352, 348, 23, 69, 23, 
+	347, 69, 23, 7, 23, 49, 353, 348, 
+	23, 69, 23, 347, 69, 23, 7, 23, 
+	49, 348, 354, 23, 69, 23, 347, 69, 
+	23, 7, 355, 49, 348, 23, 69, 23, 
+	347, 356, 7, 23, 357, 7, 23, 7, 
+	358, 23, 359, 7, 359, 359, 23, 7, 
+	360, 23, 7, 347, 23, 7, 362, 66, 
+	71, 23, 66, 68, 70, 7, 824, 23, 
+	7, 362, 23, 365, 7, 23, 7, 366, 
+	23, 7, 824, 23, 49, 368, 48, 49, 
+	69, 65, 64, 23, 64, 71, 343, 822, 
+	23, 49, 23, 68, 70, 7, 366, 51, 
+	51, 23, 49, 50, 48, 49, 69, 65, 
+	64, 370, 64, 71, 343, 822, 23, 49, 
+	23, 68, 70, 49, 50, 48, 49, 69, 
+	65, 64, 23, 64, 822, 71, 343, 822, 
+	23, 49, 23, 68, 70, 63, 372, 338, 
+	371, 63, 400, 400, 400, 62, 7, 8, 
+	6, 23, 24, 5, 373, 5, 374, 30, 
+	377, 825, 0, 7, 0, 374, 27, 29, 
+	4, 3, 374, 30, 0, 4, 0, 374, 
+	27, 29, 7, 8, 6, 7, 23, 24, 
+	373, 375, 374, 30, 377, 825, 0, 7, 
+	0, 5, 374, 27, 29, 376, 0, 7, 
+	8, 6, 7, 23, 24, 5, 26, 5, 
+	25, 30, 377, 825, 0, 7, 0, 25, 
+	27, 29, 7, 8, 6, 23, 28, 24, 
+	5, 0, 5, 30, 378, 377, 825, 0, 
+	7, 0, 27, 29, 7, 8, 6, 23, 
+	28, 24, 5, 0, 5, 30, 379, 377, 
+	825, 0, 7, 0, 27, 29, 7, 8, 
+	6, 23, 380, 24, 5, 0, 5, 30, 
+	377, 825, 0, 7, 0, 27, 29, 380, 
+	120, 174, 0, 7, 382, 0, 380, 0, 
+	381, 28, 0, 7, 382, 0, 28, 0, 
+	0, 381, 28, 0, 7, 382, 0, 28, 
+	0, 0, 383, 383, 383, 381, 28, 0, 
+	7, 382, 384, 0, 28, 0, 0, 381, 
+	28, 0, 7, 385, 382, 0, 28, 0, 
+	0, 381, 28, 0, 7, 386, 382, 0, 
+	28, 0, 0, 381, 28, 0, 7, 387, 
+	382, 0, 28, 0, 0, 381, 28, 0, 
+	7, 382, 388, 0, 28, 0, 0, 381, 
+	28, 0, 0, 389, 7, 382, 0, 28, 
+	0, 381, 390, 0, 391, 0, 392, 0, 
+	393, 393, 393, 0, 394, 0, 381, 0, 
+	19, 25, 30, 0, 25, 27, 29, 7, 
+	397, 6, 23, 28, 24, 5, 0, 5, 
+	30, 377, 825, 0, 7, 0, 27, 29, 
+	22, 9, 9, 0, 7, 8, 6, 23, 
+	28, 24, 5, 399, 5, 30, 377, 825, 
+	0, 7, 0, 27, 29, 7, 8, 6, 
+	23, 28, 24, 5, 0, 5, 825, 30, 
+	377, 825, 0, 7, 0, 27, 29, 63, 
+	7, 338, 371, 401, 23, 63, 23, 23, 
+	62, 63, 7, 402, 338, 371, 23, 63, 
+	23, 23, 62, 63, 7, 403, 338, 371, 
+	23, 63, 23, 23, 62, 7, 404, 23, 
+	7, 405, 23, 7, 406, 23, 407, 7, 
+	23, 408, 7, 23, 7, 409, 23, 410, 
+	7, 410, 410, 23, 7, 411, 23, 7, 
+	62, 23, 119, 121, 136, 118, 137, 135, 
+	413, 135, 414, 143, 417, 827, 120, 119, 
+	120, 414, 140, 142, 134, 28, 133, 414, 
+	143, 120, 134, 120, 414, 140, 142, 119, 
+	121, 136, 119, 118, 137, 413, 415, 414, 
+	143, 417, 827, 120, 119, 120, 135, 414, 
+	140, 142, 28, 416, 120, 119, 121, 136, 
+	119, 118, 137, 135, 139, 135, 138, 143, 
+	417, 827, 120, 119, 120, 138, 140, 142, 
+	119, 121, 136, 118, 141, 137, 135, 120, 
+	135, 143, 418, 417, 827, 120, 119, 120, 
+	140, 142, 119, 121, 136, 118, 141, 137, 
+	135, 120, 135, 143, 419, 417, 827, 120, 
+	119, 120, 140, 142, 119, 121, 136, 118, 
+	420, 137, 135, 120, 135, 143, 417, 827, 
+	120, 119, 120, 140, 142, 420, 141, 243, 
+	120, 119, 422, 120, 420, 120, 421, 141, 
+	28, 119, 422, 120, 141, 120, 120, 421, 
+	141, 28, 119, 422, 120, 141, 120, 120, 
+	423, 423, 423, 421, 141, 28, 119, 422, 
+	424, 120, 141, 120, 120, 421, 141, 28, 
+	119, 425, 422, 120, 141, 120, 120, 421, 
+	141, 28, 119, 426, 422, 120, 141, 120, 
+	120, 421, 141, 28, 119, 427, 422, 120, 
+	141, 120, 120, 421, 141, 28, 119, 422, 
+	428, 120, 141, 120, 120, 421, 141, 28, 
+	120, 429, 119, 422, 120, 141, 120, 421, 
+	430, 28, 120, 431, 28, 120, 28, 432, 
+	120, 433, 28, 433, 433, 120, 28, 434, 
+	120, 28, 421, 120, 28, 436, 138, 143, 
+	120, 138, 140, 142, 28, 829, 120, 28, 
+	436, 120, 439, 28, 120, 28, 440, 120, 
+	28, 829, 120, 119, 442, 136, 118, 141, 
+	137, 135, 120, 135, 143, 417, 827, 120, 
+	119, 120, 140, 142, 28, 440, 122, 122, 
+	120, 119, 121, 136, 118, 141, 137, 135, 
+	444, 135, 143, 417, 827, 120, 119, 120, 
+	140, 142, 119, 121, 136, 118, 141, 137, 
+	135, 120, 135, 827, 143, 417, 827, 120, 
+	119, 120, 140, 142, 282, 69, 119, 332, 
+	335, 446, 118, 282, 118, 118, 281, 282, 
+	69, 119, 447, 332, 335, 118, 282, 118, 
+	118, 281, 282, 69, 119, 448, 332, 335, 
+	118, 282, 118, 118, 281, 69, 119, 449, 
+	118, 69, 119, 450, 118, 69, 119, 451, 
+	118, 452, 69, 119, 118, 453, 69, 119, 
+	118, 69, 119, 454, 118, 455, 69, 119, 
+	455, 455, 118, 69, 119, 456, 118, 69, 
+	119, 281, 118, 458, 69, 119, 332, 457, 
+	335, 830, 118, 458, 118, 118, 281, 458, 
+	69, 119, 280, 118, 332, 457, 335, 830, 
+	118, 458, 118, 281, 282, 69, 119, 460, 
+	332, 335, 118, 282, 118, 281, 282, 69, 
+	119, 332, 830, 335, 118, 282, 118, 118, 
+	281, 282, 315, 69, 119, 332, 335, 118, 
+	282, 118, 118, 281, 463, 244, 218, 259, 
+	264, 242, 260, 258, 243, 258, 266, 464, 
+	832, 243, 463, 243, 263, 265, 463, 244, 
+	218, 259, 242, 260, 258, 262, 258, 261, 
+	266, 464, 832, 243, 463, 243, 261, 263, 
+	265, 242, 244, 218, 259, 264, 260, 258, 
+	243, 258, 266, 465, 464, 832, 243, 242, 
+	243, 263, 265, 242, 244, 218, 259, 264, 
+	260, 258, 243, 258, 266, 466, 464, 832, 
+	243, 242, 243, 263, 265, 242, 244, 218, 
+	259, 467, 260, 258, 243, 258, 266, 464, 
+	832, 243, 242, 243, 263, 265, 467, 264, 
+	264, 243, 242, 469, 243, 467, 243, 468, 
+	264, 194, 141, 243, 242, 469, 243, 264, 
+	243, 468, 264, 194, 141, 243, 242, 469, 
+	243, 264, 243, 470, 470, 470, 468, 264, 
+	194, 141, 243, 242, 469, 471, 243, 264, 
+	243, 468, 264, 194, 141, 243, 242, 472, 
+	469, 243, 264, 243, 468, 264, 194, 141, 
+	243, 242, 473, 469, 243, 264, 243, 468, 
+	264, 194, 141, 243, 242, 474, 469, 243, 
+	264, 243, 468, 264, 194, 141, 243, 242, 
+	469, 475, 243, 264, 243, 468, 264, 194, 
+	141, 476, 242, 469, 243, 264, 243, 468, 
+	477, 194, 141, 243, 478, 194, 141, 243, 
+	194, 141, 479, 243, 480, 194, 141, 480, 
+	480, 243, 194, 141, 481, 243, 194, 141, 
+	468, 243, 194, 141, 483, 261, 266, 243, 
+	261, 263, 265, 194, 141, 834, 243, 194, 
+	141, 483, 243, 486, 194, 141, 243, 194, 
+	141, 487, 243, 194, 141, 834, 243, 242, 
+	489, 218, 259, 264, 260, 258, 243, 258, 
+	266, 464, 832, 243, 242, 243, 263, 265, 
+	194, 141, 487, 245, 245, 243, 242, 244, 
+	218, 259, 264, 260, 258, 491, 258, 266, 
+	464, 832, 243, 242, 243, 263, 265, 242, 
+	244, 218, 259, 264, 260, 258, 243, 258, 
+	832, 266, 464, 832, 243, 242, 243, 263, 
+	265, 242, 244, 218, 242, 259, 264, 260, 
+	258, 493, 258, 266, 464, 495, 832, 243, 
+	242, 243, 263, 265, 194, 141, 494, 243, 
+	242, 244, 218, 242, 259, 260, 258, 262, 
+	258, 261, 266, 464, 832, 243, 242, 243, 
+	261, 263, 265, 242, 244, 218, 259, 264, 
+	260, 258, 243, 258, 496, 266, 464, 832, 
+	243, 242, 243, 263, 265, 242, 244, 218, 
+	242, 259, 264, 260, 497, 493, 258, 266, 
+	464, 832, 243, 242, 243, 263, 265, 258, 
+	218, 259, 260, 262, 498, 261, 266, 464, 
+	243, 258, 243, 261, 263, 265, 242, 244, 
+	218, 242, 259, 264, 260, 258, 493, 258, 
+	266, 464, 835, 243, 242, 243, 263, 265, 
+	500, 264, 194, 141, 242, 264, 243, 501, 
+	264, 194, 141, 242, 264, 243, 264, 194, 
+	141, 242, 502, 264, 243, 503, 194, 141, 
+	503, 503, 243, 194, 141, 504, 243, 194, 
+	141, 265, 243, 242, 244, 218, 259, 264, 
+	260, 258, 243, 258, 266, 464, 495, 832, 
+	243, 242, 243, 263, 265, 258, 218, 259, 
+	260, 507, 508, 266, 464, 243, 258, 243, 
+	508, 263, 265, 257, 194, 141, 256, 508, 
+	266, 243, 257, 243, 508, 263, 265, 242, 
+	244, 218, 242, 259, 260, 507, 493, 508, 
+	266, 464, 832, 243, 242, 243, 258, 508, 
+	263, 265, 257, 510, 574, 506, 509, 257, 
+	590, 590, 590, 256, 511, 28, 173, 512, 
+	545, 174, 511, 174, 174, 187, 511, 28, 
+	173, 189, 511, 174, 189, 172, 69, 190, 
+	513, 514, 196, 517, 174, 189, 174, 514, 
+	193, 195, 188, 28, 187, 514, 196, 174, 
+	188, 174, 514, 193, 195, 173, 175, 172, 
+	173, 69, 190, 513, 515, 514, 196, 517, 
+	836, 174, 173, 174, 189, 514, 193, 195, 
+	28, 516, 174, 173, 175, 172, 173, 69, 
+	190, 189, 192, 189, 191, 196, 517, 836, 
+	174, 173, 174, 191, 193, 195, 173, 175, 
+	172, 69, 194, 190, 189, 174, 189, 196, 
+	518, 517, 836, 174, 173, 174, 193, 195, 
+	173, 175, 172, 69, 194, 190, 189, 174, 
+	189, 196, 519, 517, 836, 174, 173, 174, 
+	193, 195, 173, 175, 172, 69, 520, 190, 
+	189, 174, 189, 196, 517, 836, 174, 173, 
+	174, 193, 195, 520, 243, 194, 174, 173, 
+	522, 174, 520, 174, 521, 194, 174, 28, 
+	174, 173, 522, 174, 194, 174, 521, 194, 
+	174, 28, 174, 173, 522, 174, 194, 174, 
+	523, 523, 523, 521, 194, 174, 28, 174, 
+	173, 522, 524, 174, 194, 174, 521, 194, 
+	174, 28, 174, 173, 525, 522, 174, 194, 
+	174, 521, 194, 174, 28, 174, 173, 526, 
+	522, 174, 194, 174, 521, 194, 174, 28, 
+	174, 173, 527, 522, 174, 194, 174, 521, 
+	194, 174, 28, 174, 173, 522, 528, 174, 
+	194, 174, 521, 194, 174, 28, 529, 173, 
+	522, 174, 194, 174, 521, 530, 28, 174, 
+	531, 28, 174, 28, 532, 174, 533, 28, 
+	533, 533, 174, 28, 534, 174, 28, 521, 
+	174, 28, 536, 191, 196, 174, 191, 193, 
+	195, 28, 838, 174, 28, 536, 174, 539, 
+	28, 174, 28, 540, 174, 28, 838, 174, 
+	173, 542, 172, 69, 194, 190, 189, 174, 
+	189, 196, 517, 836, 174, 173, 174, 193, 
+	195, 28, 540, 176, 176, 174, 173, 175, 
+	172, 69, 194, 190, 189, 544, 189, 196, 
+	517, 836, 174, 173, 174, 193, 195, 173, 
+	175, 172, 69, 194, 190, 189, 174, 189, 
+	836, 196, 517, 836, 174, 173, 174, 193, 
+	195, 188, 546, 512, 545, 188, 562, 562, 
+	562, 187, 547, 7, 548, 549, 0, 547, 
+	0, 0, 3, 547, 7, 5, 547, 0, 
+	5, 6, 23, 24, 373, 374, 30, 377, 
+	0, 5, 0, 374, 27, 29, 4, 548, 
+	549, 4, 550, 550, 550, 3, 4, 548, 
+	549, 551, 0, 4, 0, 0, 3, 4, 
+	552, 548, 549, 0, 4, 0, 0, 3, 
+	4, 553, 548, 549, 0, 4, 0, 0, 
+	3, 554, 0, 555, 0, 556, 0, 557, 
+	0, 558, 0, 559, 0, 560, 560, 560, 
+	0, 561, 0, 3, 0, 188, 28, 512, 
+	545, 563, 174, 188, 174, 174, 187, 188, 
+	28, 564, 512, 545, 174, 188, 174, 174, 
+	187, 188, 28, 565, 512, 545, 174, 188, 
+	174, 174, 187, 28, 566, 174, 28, 567, 
+	174, 28, 568, 174, 569, 28, 174, 570, 
+	28, 174, 28, 571, 174, 572, 28, 572, 
+	572, 174, 28, 573, 174, 28, 187, 174, 
+	575, 28, 119, 576, 577, 120, 575, 120, 
+	120, 133, 575, 28, 119, 135, 575, 120, 
+	135, 136, 118, 137, 413, 414, 143, 417, 
+	120, 135, 120, 414, 140, 142, 134, 546, 
+	576, 577, 134, 578, 578, 578, 133, 134, 
+	28, 576, 577, 579, 120, 134, 120, 120, 
+	133, 134, 28, 580, 576, 577, 120, 134, 
+	120, 120, 133, 134, 28, 581, 576, 577, 
+	120, 134, 120, 120, 133, 28, 582, 120, 
+	28, 583, 120, 28, 584, 120, 585, 28, 
+	120, 586, 28, 120, 28, 587, 120, 588, 
+	28, 588, 588, 120, 28, 589, 120, 28, 
+	133, 120, 257, 194, 141, 506, 509, 591, 
+	243, 257, 243, 243, 256, 257, 194, 141, 
+	592, 506, 509, 243, 257, 243, 243, 256, 
+	257, 194, 141, 593, 506, 509, 243, 257, 
+	243, 243, 256, 194, 141, 594, 243, 194, 
+	141, 595, 243, 194, 141, 596, 243, 597, 
+	194, 141, 243, 598, 194, 141, 243, 194, 
+	141, 599, 243, 600, 194, 141, 600, 600, 
+	243, 194, 141, 601, 243, 194, 141, 256, 
+	243, 603, 194, 141, 506, 602, 509, 839, 
+	243, 603, 243, 243, 256, 603, 194, 141, 
+	255, 243, 506, 602, 509, 839, 243, 603, 
+	243, 256, 257, 194, 141, 605, 506, 509, 
+	243, 257, 243, 256, 257, 194, 141, 506, 
+	839, 509, 243, 257, 243, 243, 256, 257, 
+	486, 194, 141, 506, 509, 243, 257, 243, 
+	243, 256, 173, 136, 608, 215, 221, 172, 
+	215, 217, 197, 173, 136, 843, 172, 173, 
+	136, 608, 172, 611, 173, 136, 172, 173, 
+	136, 612, 172, 173, 136, 843, 172, 198, 
+	614, 198, 93, 218, 214, 213, 172, 213, 
+	221, 224, 841, 172, 198, 172, 217, 197, 
+	173, 136, 612, 200, 200, 172, 198, 199, 
+	198, 93, 218, 214, 213, 616, 213, 221, 
+	224, 841, 172, 198, 172, 217, 197, 198, 
+	199, 198, 93, 218, 214, 213, 172, 213, 
+	841, 221, 224, 841, 172, 198, 172, 217, 
+	197, 198, 199, 198, 198, 93, 218, 214, 
+	213, 219, 213, 221, 224, 618, 841, 172, 
+	198, 172, 217, 197, 198, 199, 198, 93, 
+	218, 214, 213, 172, 213, 619, 221, 224, 
+	841, 172, 198, 172, 217, 197, 198, 199, 
+	198, 198, 93, 218, 214, 620, 219, 213, 
+	221, 224, 841, 172, 198, 172, 217, 197, 
+	213, 198, 93, 214, 216, 621, 215, 221, 
+	224, 172, 213, 172, 215, 217, 197, 198, 
+	199, 198, 198, 93, 218, 214, 213, 219, 
+	213, 221, 224, 844, 172, 198, 172, 217, 
+	197, 623, 218, 173, 136, 198, 218, 172, 
+	624, 218, 173, 136, 198, 218, 172, 218, 
+	173, 136, 198, 625, 218, 172, 626, 173, 
+	136, 626, 626, 172, 173, 136, 627, 172, 
+	173, 136, 197, 172, 198, 199, 198, 93, 
+	218, 214, 213, 172, 213, 221, 224, 618, 
+	841, 172, 198, 172, 217, 197, 213, 198, 
+	93, 214, 630, 631, 221, 224, 172, 213, 
+	172, 631, 217, 197, 212, 173, 136, 211, 
+	631, 221, 172, 212, 172, 631, 217, 197, 
+	198, 199, 198, 198, 93, 214, 630, 219, 
+	631, 221, 224, 841, 172, 198, 172, 213, 
+	631, 217, 197, 212, 633, 634, 629, 632, 
+	212, 662, 662, 662, 211, 173, 175, 172, 
+	69, 190, 189, 513, 189, 514, 196, 517, 
+	836, 174, 173, 174, 514, 193, 195, 635, 
+	7, 32, 636, 649, 6, 635, 6, 6, 
+	45, 635, 7, 32, 47, 635, 6, 47, 
+	32, 48, 146, 637, 638, 152, 154, 6, 
+	47, 6, 638, 149, 31, 46, 7, 45, 
+	638, 152, 6, 46, 6, 638, 149, 31, 
+	32, 33, 32, 32, 48, 146, 637, 150, 
+	638, 152, 154, 845, 6, 32, 6, 47, 
+	638, 149, 31, 7, 640, 147, 152, 6, 
+	147, 149, 31, 7, 847, 6, 7, 640, 
+	6, 643, 7, 6, 7, 644, 6, 7, 
+	847, 6, 32, 646, 32, 48, 136, 146, 
+	47, 6, 47, 152, 154, 845, 6, 32, 
+	6, 149, 31, 7, 644, 34, 34, 6, 
+	32, 33, 32, 48, 136, 146, 47, 648, 
+	47, 152, 154, 845, 6, 32, 6, 149, 
+	31, 32, 33, 32, 48, 136, 146, 47, 
+	6, 47, 845, 152, 154, 845, 6, 32, 
+	6, 149, 31, 46, 372, 636, 649, 46, 
+	650, 650, 650, 45, 46, 7, 636, 649, 
+	651, 6, 46, 6, 6, 45, 46, 7, 
+	652, 636, 649, 6, 46, 6, 6, 45, 
+	46, 7, 653, 636, 649, 6, 46, 6, 
+	6, 45, 7, 654, 6, 7, 655, 6, 
+	7, 656, 6, 657, 7, 6, 658, 7, 
+	6, 7, 659, 6, 660, 7, 660, 660, 
+	6, 7, 661, 6, 7, 45, 6, 212, 
+	173, 136, 629, 632, 663, 172, 212, 172, 
+	172, 211, 212, 173, 136, 664, 629, 632, 
+	172, 212, 172, 172, 211, 212, 173, 136, 
+	665, 629, 632, 172, 212, 172, 172, 211, 
+	173, 136, 666, 172, 173, 136, 667, 172, 
+	173, 136, 668, 172, 669, 173, 136, 172, 
+	670, 173, 136, 172, 173, 136, 671, 172, 
+	672, 173, 136, 672, 672, 172, 173, 136, 
+	673, 172, 173, 136, 211, 172, 675, 173, 
+	136, 629, 674, 632, 848, 172, 675, 172, 
+	172, 211, 675, 173, 136, 210, 172, 629, 
+	674, 632, 848, 172, 675, 172, 211, 212, 
+	173, 136, 677, 629, 632, 172, 212, 172, 
+	211, 212, 173, 136, 629, 848, 632, 172, 
+	212, 172, 172, 211, 212, 611, 173, 136, 
+	629, 632, 172, 212, 172, 172, 211, 680, 
+	50, 48, 49, 69, 49, 65, 64, 23, 
+	64, 71, 343, 822, 23, 680, 23, 68, 
+	70, 680, 50, 48, 49, 49, 65, 64, 
+	67, 64, 66, 71, 343, 822, 23, 680, 
+	23, 66, 68, 70, 682, 175, 172, 69, 
+	194, 173, 190, 189, 174, 189, 196, 517, 
+	836, 174, 682, 174, 193, 195, 682, 175, 
+	172, 69, 173, 190, 189, 192, 189, 191, 
+	196, 517, 836, 174, 682, 174, 191, 193, 
+	195, 173, 175, 172, 173, 69, 194, 190, 
+	189, 515, 189, 196, 517, 684, 836, 174, 
+	173, 174, 193, 195, 173, 175, 172, 69, 
+	194, 190, 189, 174, 189, 685, 196, 517, 
+	836, 174, 173, 174, 193, 195, 173, 175, 
+	172, 173, 69, 194, 190, 686, 515, 189, 
+	196, 517, 836, 174, 173, 174, 193, 195, 
+	189, 172, 69, 190, 192, 687, 191, 196, 
+	517, 174, 189, 174, 191, 193, 195, 173, 
+	175, 172, 173, 69, 194, 190, 189, 515, 
+	189, 196, 517, 850, 174, 173, 174, 193, 
+	195, 689, 194, 28, 173, 194, 174, 690, 
+	194, 28, 173, 194, 174, 194, 28, 173, 
+	691, 194, 174, 692, 28, 692, 692, 174, 
+	28, 693, 174, 28, 195, 174, 173, 175, 
+	172, 69, 194, 190, 189, 174, 189, 196, 
+	517, 684, 836, 174, 173, 174, 193, 195, 
+	696, 28, 512, 695, 545, 851, 174, 696, 
+	174, 174, 187, 696, 28, 186, 174, 512, 
+	695, 545, 851, 174, 696, 174, 187, 188, 
+	28, 698, 512, 545, 174, 188, 174, 187, 
+	188, 28, 512, 851, 545, 174, 188, 174, 
+	174, 187, 188, 539, 28, 512, 545, 174, 
+	188, 174, 174, 187, 32, 33, 32, 48, 
+	136, 146, 47, 6, 47, 701, 152, 154, 
+	845, 6, 32, 6, 149, 31, 32, 33, 
+	32, 32, 48, 136, 146, 702, 150, 47, 
+	152, 154, 845, 6, 32, 6, 149, 31, 
+	47, 32, 48, 146, 148, 703, 147, 152, 
+	154, 6, 47, 6, 147, 149, 31, 32, 
+	33, 32, 32, 48, 136, 146, 47, 150, 
+	47, 152, 154, 853, 6, 32, 6, 149, 
+	31, 705, 136, 7, 32, 136, 6, 706, 
+	136, 7, 32, 136, 6, 136, 7, 32, 
+	707, 136, 6, 708, 7, 708, 708, 6, 
+	7, 709, 6, 7, 31, 6, 32, 33, 
+	32, 48, 136, 146, 47, 6, 47, 152, 
+	154, 700, 845, 6, 32, 6, 149, 31, 
+	712, 121, 136, 118, 141, 119, 137, 135, 
+	120, 135, 143, 417, 827, 120, 712, 120, 
+	140, 142, 712, 121, 136, 118, 119, 137, 
+	135, 139, 135, 138, 143, 417, 827, 120, 
+	712, 120, 138, 140, 142, 119, 121, 136, 
+	119, 118, 141, 137, 135, 415, 135, 143, 
+	417, 714, 827, 120, 119, 120, 140, 142, 
+	119, 121, 136, 118, 141, 137, 135, 120, 
+	135, 715, 143, 417, 827, 120, 119, 120, 
+	140, 142, 119, 121, 136, 119, 118, 141, 
+	137, 716, 415, 135, 143, 417, 827, 120, 
+	119, 120, 140, 142, 135, 136, 118, 137, 
+	139, 717, 138, 143, 417, 120, 135, 120, 
+	138, 140, 142, 119, 121, 136, 119, 118, 
+	141, 137, 135, 415, 135, 143, 417, 854, 
+	120, 119, 120, 140, 142, 719, 141, 28, 
+	119, 141, 120, 720, 141, 28, 119, 141, 
+	120, 141, 28, 119, 721, 141, 120, 722, 
+	28, 722, 722, 120, 28, 723, 120, 28, 
+	142, 120, 119, 121, 136, 118, 141, 137, 
+	135, 120, 135, 143, 417, 714, 827, 120, 
+	119, 120, 140, 142, 726, 28, 576, 725, 
+	577, 855, 120, 726, 120, 120, 133, 726, 
+	28, 132, 120, 576, 725, 577, 855, 120, 
+	726, 120, 133, 134, 28, 728, 576, 577, 
+	120, 134, 120, 133, 134, 28, 576, 855, 
+	577, 120, 134, 120, 120, 133, 134, 439, 
+	28, 576, 577, 120, 134, 120, 120, 133, 
+	49, 32, 731, 90, 96, 48, 90, 92, 
+	72, 49, 32, 859, 48, 49, 32, 731, 
+	48, 734, 49, 32, 48, 49, 32, 735, 
+	48, 49, 32, 859, 48, 73, 737, 73, 
+	73, 93, 89, 88, 48, 88, 96, 99, 
+	857, 48, 73, 48, 92, 72, 49, 32, 
+	735, 75, 75, 48, 73, 74, 73, 73, 
+	93, 89, 88, 739, 88, 96, 99, 857, 
+	48, 73, 48, 92, 72, 73, 74, 73, 
+	73, 93, 89, 88, 48, 88, 857, 96, 
+	99, 857, 48, 73, 48, 92, 72, 73, 
+	74, 73, 73, 73, 93, 89, 88, 94, 
+	88, 96, 99, 741, 857, 48, 73, 48, 
+	92, 72, 73, 74, 73, 73, 93, 89, 
+	88, 48, 88, 742, 96, 99, 857, 48, 
+	73, 48, 92, 72, 73, 74, 73, 73, 
+	73, 93, 89, 743, 94, 88, 96, 99, 
+	857, 48, 73, 48, 92, 72, 88, 73, 
+	73, 89, 91, 744, 90, 96, 99, 48, 
+	88, 48, 90, 92, 72, 73, 74, 73, 
+	73, 73, 93, 89, 88, 94, 88, 96, 
+	99, 860, 48, 73, 48, 92, 72, 746, 
+	93, 49, 32, 73, 93, 48, 747, 93, 
+	49, 32, 73, 93, 48, 93, 49, 32, 
+	73, 748, 93, 48, 749, 49, 32, 749, 
+	749, 48, 49, 32, 750, 48, 49, 32, 
+	72, 48, 73, 74, 73, 73, 93, 89, 
+	88, 48, 88, 96, 99, 741, 857, 48, 
+	73, 48, 92, 72, 88, 73, 73, 89, 
+	753, 754, 96, 99, 48, 88, 48, 754, 
+	92, 72, 87, 49, 32, 86, 754, 96, 
+	48, 87, 48, 754, 92, 72, 73, 74, 
+	73, 73, 73, 89, 753, 94, 754, 96, 
+	99, 857, 48, 73, 48, 88, 754, 92, 
+	72, 87, 756, 757, 752, 755, 87, 758, 
+	758, 758, 86, 49, 50, 48, 49, 65, 
+	64, 339, 64, 340, 71, 343, 822, 23, 
+	49, 23, 340, 68, 70, 32, 33, 32, 
+	48, 146, 47, 637, 47, 638, 152, 154, 
+	845, 6, 32, 6, 638, 149, 31, 87, 
+	49, 32, 752, 755, 759, 48, 87, 48, 
+	48, 86, 87, 49, 32, 760, 752, 755, 
+	48, 87, 48, 48, 86, 87, 49, 32, 
+	761, 752, 755, 48, 87, 48, 48, 86, 
+	49, 32, 762, 48, 49, 32, 763, 48, 
+	49, 32, 764, 48, 765, 49, 32, 48, 
+	766, 49, 32, 48, 49, 32, 767, 48, 
+	768, 49, 32, 768, 768, 48, 49, 32, 
+	769, 48, 49, 32, 86, 48, 771, 49, 
+	32, 752, 770, 755, 861, 48, 771, 48, 
+	48, 86, 771, 49, 32, 85, 48, 752, 
+	770, 755, 861, 48, 771, 48, 86, 87, 
+	49, 32, 773, 752, 755, 48, 87, 48, 
+	86, 87, 49, 32, 752, 861, 755, 48, 
+	87, 48, 48, 86, 87, 734, 49, 32, 
+	752, 755, 48, 87, 48, 48, 86, 49, 
+	50, 48, 49, 49, 69, 65, 64, 341, 
+	64, 71, 343, 776, 822, 23, 49, 23, 
+	68, 70, 49, 50, 48, 49, 69, 65, 
+	64, 23, 64, 777, 71, 343, 822, 23, 
+	49, 23, 68, 70, 49, 50, 48, 49, 
+	49, 69, 65, 778, 341, 64, 71, 343, 
+	822, 23, 49, 23, 68, 70, 64, 48, 
+	49, 65, 67, 779, 66, 71, 343, 23, 
+	64, 23, 66, 68, 70, 49, 50, 48, 
+	49, 49, 69, 65, 64, 341, 64, 71, 
+	343, 863, 23, 49, 23, 68, 70, 781, 
+	69, 7, 49, 69, 23, 782, 69, 7, 
+	49, 69, 23, 69, 7, 49, 783, 69, 
+	23, 784, 7, 784, 784, 23, 7, 785, 
+	23, 7, 70, 23, 49, 50, 48, 49, 
+	69, 65, 64, 23, 64, 71, 343, 776, 
+	822, 23, 49, 23, 68, 70, 788, 7, 
+	338, 787, 371, 864, 23, 788, 23, 23, 
+	62, 788, 7, 61, 23, 338, 787, 371, 
+	864, 23, 788, 23, 62, 63, 7, 790, 
+	338, 371, 23, 63, 23, 62, 63, 7, 
+	338, 864, 371, 23, 63, 23, 23, 62, 
+	63, 365, 7, 338, 371, 23, 63, 23, 
+	23, 62, 793, 7, 636, 792, 649, 866, 
+	6, 793, 6, 6, 45, 793, 7, 44, 
+	6, 636, 792, 649, 866, 6, 793, 6, 
+	45, 46, 7, 795, 636, 649, 6, 46, 
+	6, 45, 46, 7, 636, 866, 649, 6, 
+	46, 6, 6, 45, 46, 643, 7, 636, 
+	649, 6, 46, 6, 6, 45, 798, 8, 
+	6, 23, 28, 7, 24, 5, 0, 5, 
+	30, 377, 825, 0, 798, 0, 27, 29, 
+	798, 8, 6, 23, 7, 24, 5, 26, 
+	5, 25, 30, 377, 825, 0, 798, 0, 
+	25, 27, 29, 7, 8, 6, 7, 23, 
+	28, 24, 5, 375, 5, 30, 377, 800, 
+	825, 0, 7, 0, 27, 29, 7, 8, 
+	6, 23, 28, 24, 5, 0, 5, 801, 
+	30, 377, 825, 0, 7, 0, 27, 29, 
+	7, 8, 6, 7, 23, 28, 24, 802, 
+	375, 5, 30, 377, 825, 0, 7, 0, 
+	27, 29, 5, 6, 23, 24, 26, 803, 
+	25, 30, 377, 0, 5, 0, 25, 27, 
+	29, 7, 8, 6, 7, 23, 28, 24, 
+	5, 375, 5, 30, 377, 868, 0, 7, 
+	0, 27, 29, 805, 28, 7, 28, 0, 
+	806, 28, 7, 28, 0, 28, 7, 807, 
+	28, 0, 808, 808, 808, 0, 809, 0, 
+	29, 0, 7, 8, 6, 23, 28, 24, 
+	5, 0, 5, 30, 377, 800, 825, 0, 
+	7, 0, 27, 29, 812, 548, 811, 549, 
+	869, 0, 812, 0, 0, 3, 812, 2, 
+	0, 548, 811, 549, 869, 0, 812, 0, 
+	3, 4, 814, 548, 549, 0, 4, 0, 
+	3, 4, 548, 869, 549, 0, 4, 0, 
+	0, 3, 4, 21, 548, 549, 0, 4, 
+	0, 0, 3, 1, 0, 817, 18, 20, 
+	1, 817, 0, 819, 269, 93, 117, 259, 
+	284, 283, 319, 283, 317, 289, 293, 818, 
+	118, 819, 118, 287, 288, 819, 269, 93, 
+	117, 284, 283, 311, 283, 285, 317, 289, 
+	293, 818, 118, 819, 118, 285, 287, 288, 
+	820, 69, 119, 313, 314, 279, 820, 118, 
+	819, 269, 93, 117, 325, 284, 283, 319, 
+	283, 317, 289, 293, 818, 118, 819, 118, 
+	287, 288, 823, 50, 48, 49, 69, 65, 
+	64, 369, 64, 367, 71, 343, 822, 23, 
+	823, 23, 68, 70, 823, 50, 48, 49, 
+	65, 64, 361, 64, 66, 367, 71, 343, 
+	822, 23, 823, 23, 66, 68, 70, 824, 
+	7, 363, 364, 60, 824, 23, 826, 8, 
+	6, 23, 28, 24, 5, 398, 5, 396, 
+	30, 377, 825, 0, 826, 0, 27, 29, 
+	826, 8, 6, 23, 24, 5, 395, 5, 
+	25, 396, 30, 377, 825, 0, 826, 0, 
+	25, 27, 29, 828, 121, 136, 118, 141, 
+	137, 135, 443, 135, 441, 143, 417, 827, 
+	120, 828, 120, 140, 142, 828, 121, 136, 
+	118, 137, 135, 435, 135, 138, 441, 143, 
+	417, 827, 120, 828, 120, 138, 140, 142, 
+	829, 28, 437, 438, 131, 829, 120, 831, 
+	69, 119, 459, 332, 461, 335, 457, 118, 
+	831, 118, 281, 831, 69, 119, 313, 283, 
+	314, 279, 831, 118, 833, 244, 218, 259, 
+	264, 260, 258, 490, 258, 488, 266, 464, 
+	832, 243, 833, 243, 263, 265, 833, 244, 
+	218, 259, 260, 258, 482, 258, 261, 488, 
+	266, 464, 832, 243, 833, 243, 261, 263, 
+	265, 834, 194, 141, 484, 485, 254, 834, 
+	243, 833, 244, 218, 259, 499, 260, 258, 
+	490, 258, 488, 266, 464, 832, 243, 833, 
+	243, 263, 265, 837, 175, 172, 69, 194, 
+	190, 189, 543, 189, 541, 196, 517, 836, 
+	174, 837, 174, 193, 195, 837, 175, 172, 
+	69, 190, 189, 535, 189, 191, 541, 196, 
+	517, 836, 174, 837, 174, 191, 193, 195, 
+	838, 28, 537, 538, 185, 838, 174, 840, 
+	194, 141, 604, 506, 606, 509, 602, 243, 
+	840, 243, 256, 840, 194, 141, 484, 258, 
+	485, 254, 840, 243, 842, 199, 198, 93, 
+	218, 214, 213, 615, 213, 613, 221, 224, 
+	841, 172, 842, 172, 217, 197, 842, 199, 
+	198, 93, 214, 213, 607, 213, 215, 613, 
+	221, 224, 841, 172, 842, 172, 215, 217, 
+	197, 843, 173, 136, 609, 610, 209, 843, 
+	172, 842, 199, 198, 93, 622, 214, 213, 
+	615, 213, 613, 221, 224, 841, 172, 842, 
+	172, 217, 197, 846, 33, 32, 48, 136, 
+	146, 47, 647, 47, 645, 152, 154, 845, 
+	6, 846, 6, 149, 31, 846, 33, 32, 
+	48, 146, 47, 639, 47, 147, 645, 152, 
+	154, 845, 6, 846, 6, 147, 149, 31, 
+	847, 7, 641, 642, 43, 847, 6, 849, 
+	173, 136, 676, 629, 678, 632, 674, 172, 
+	849, 172, 211, 849, 173, 136, 609, 213, 
+	610, 209, 849, 172, 837, 175, 172, 69, 
+	688, 190, 189, 543, 189, 541, 196, 517, 
+	836, 174, 837, 174, 193, 195, 852, 28, 
+	697, 512, 699, 545, 695, 174, 852, 174, 
+	187, 852, 28, 537, 189, 538, 185, 852, 
+	174, 846, 33, 32, 48, 704, 146, 47, 
+	647, 47, 645, 152, 154, 845, 6, 846, 
+	6, 149, 31, 828, 121, 136, 118, 718, 
+	137, 135, 443, 135, 441, 143, 417, 827, 
+	120, 828, 120, 140, 142, 856, 28, 727, 
+	576, 729, 577, 725, 120, 856, 120, 133, 
+	856, 28, 437, 135, 438, 131, 856, 120, 
+	858, 74, 73, 73, 93, 89, 88, 738, 
+	88, 736, 96, 99, 857, 48, 858, 48, 
+	92, 72, 858, 74, 73, 73, 89, 88, 
+	730, 88, 90, 736, 96, 99, 857, 48, 
+	858, 48, 90, 92, 72, 859, 49, 32, 
+	732, 733, 84, 859, 48, 858, 74, 73, 
+	73, 745, 89, 88, 738, 88, 736, 96, 
+	99, 857, 48, 858, 48, 92, 72, 862, 
+	49, 32, 772, 752, 774, 755, 770, 48, 
+	862, 48, 86, 862, 49, 32, 732, 88, 
+	733, 84, 862, 48, 823, 50, 48, 49, 
+	780, 65, 64, 369, 64, 367, 71, 343, 
+	822, 23, 823, 23, 68, 70, 865, 7, 
+	789, 338, 791, 371, 787, 23, 865, 23, 
+	62, 865, 7, 363, 64, 364, 60, 865, 
+	23, 867, 7, 794, 636, 796, 649, 792, 
+	6, 867, 6, 45, 867, 7, 641, 47, 
+	642, 43, 867, 6, 826, 8, 6, 23, 
+	804, 24, 5, 398, 5, 396, 30, 377, 
+	825, 0, 826, 0, 27, 29, 870, 813, 
+	548, 815, 549, 811, 0, 870, 0, 3, 
+	870, 18, 5, 20, 1, 870, 0, 0
+};
+
+const int selector_start = 816;
+const int selector_first_final = 816;
+const int selector_error = 0;
+
+const int selector_en_main = 816;
+
+
+/* #line 58 "Parser.rl" */
+
+		#endregion
+	}
+}

Source/External/ExCSS/ParserX.cs

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ExCSS
+{
+    public sealed class CssParser
+    {
+        CssSelectorConstructor selector;
+        Stack<FunctionBuffer> function;
+        Boolean skipExceptions;
+        Lexer tokenizer;
+        Boolean fraction;
+        CSSProperty property;
+        CSSValue value;
+        List<CSSValue> mvalues;
+        CSSValueList cvalues;
+        Boolean started;
+        Boolean quirks;
+        CSSStyleSheet sheet;
+        Stack<CSSRule> open;
+        StringBuilder buffer;
+        CssState state;
+        Object sync;
+        Task task;
+
+        #region ctor
+
+
+        /// <summary>
+        /// Creates a new CSS parser instance parser with the specified stylesheet
+        /// based on the given source manager.
+        /// </summary>
+        /// <param name="stylesheet">The stylesheet to be constructed.</param>
+        /// <param name="source">The source to use.</param>
+        internal CssParser(StylesheetReader reader)
+        {
+            selector = Pool.NewSelectorConstructor();
+            sync = new Object();
+            skipExceptions = true;
+            tokenizer = new Lexer(reader);
+
+            started = false;
+            function = new Stack<FunctionBuffer>();
+            sheet = stylesheet;
+            open = new Stack<CSSRule>();
+            SwitchTo(CssState.Data);
+        }
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets if the parser has been started asynchronously.
+        /// </summary>
+        public Boolean IsAsync
+        {
+            get { return task != null; }
+        }
+
+        /// <summary>
+        /// Gets or sets if the quirks-mode is activated.
+        /// </summary>
+        public Boolean IsQuirksMode
+        {
+            get { return quirks; }
+            set { quirks = value; }
+        }
+
+        /// <summary>
+        /// Gets the current rule if any.
+        /// </summary>
+        internal CSSRule CurrentRule
+        {
+            get { return open.Count > 0 ? open.Peek() : null; }
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Parses the given source asynchronously and creates the stylesheet.
+        /// </summary>
+        /// <returns>The task which could be awaited or continued differently.</returns>
+        public Task ParseAsync()
+        {
+            lock (sync)
+            {
+                if (!started)
+                {
+                    started = true;
+                    task = Task.Run(() => Kernel());
+                }
+                else if (task == null)
+                    throw new InvalidOperationException("The parser has already run synchronously.");
+
+                return task;
+            }
+        }
+
+        /// <summary>
+        /// Parses the given source code.
+        /// </summary>
+        public void Parse()
+        {
+            var run = false;
+
+            lock (sync)
+            {
+                if (!started)
+                {
+                    started = true;
+                    run = true;
+                }
+            }
+
+            if (run)
+            {
+                Kernel();
+            }
+        }
+
+        #endregion
+
+        #region States
+
+        /// <summary>
+        /// The general state.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean Data(CssToken token)
+        {
+            if (token.Type == CssTokenType.AtKeyword)
+            {
+                switch (((CssKeywordToken)token).Data)
+                {
+                    case RuleNames.MEDIA:
+                        {
+                            AddRule(new CSSMediaRule());
+                            SwitchTo(CssState.InMediaList);
+                            break;
+                        }
+                    case RuleNames.PAGE:
+                        {
+                            AddRule(new CSSPageRule());
+                            SwitchTo(CssState.InSelector);
+                            break;
+                        }
+                    case RuleNames.IMPORT:
+                        {
+                            AddRule(new CSSImportRule());
+                            SwitchTo(CssState.BeforeImport);
+                            break;
+                        }
+                    case RuleNames.FONT_FACE:
+                        {
+                            AddRule(new CSSFontFaceRule());
+                            SwitchTo(CssState.InDeclaration);
+                            break;
+                        }
+                    case RuleNames.CHARSET:
+                        {
+                            AddRule(new CSSCharsetRule());
+                            SwitchTo(CssState.BeforeCharset);
+                            break;
+                        }
+                    case RuleNames.NAMESPACE:
+                        {
+                            AddRule(new CSSNamespaceRule());
+                            SwitchTo(CssState.BeforeNamespacePrefix);
+                            break;
+                        }
+                    case RuleNames.SUPPORTS:
+                        {
+                            buffer = Pool.NewStringBuilder();
+                            AddRule(new CSSSupportsRule());
+                            SwitchTo(CssState.InCondition);
+                            break;
+                        }
+                    case RuleNames.KEYFRAMES:
+                        {
+                            AddRule(new CSSKeyframesRule());
+                            SwitchTo(CssState.BeforeKeyframesName);
+                            break;
+                        }
+                    case RuleNames.DOCUMENT:
+                        {
+                            AddRule(new CSSDocumentRule());
+                            SwitchTo(CssState.BeforeDocumentFunction);
+                            break;
+                        }
+                    default:
+                        {
+                            buffer = Pool.NewStringBuilder();
+                            AddRule(new CSSUnknownRule());
+                            SwitchTo(CssState.InUnknown);
+                            InUnknown(token);
+                            break;
+                        }
+                }
+
+                return true;
+            }
+            else if (token.Type == CssTokenType.CurlyBracketClose)
+            {
+                return CloseRule();
+            }
+            else
+            {
+                AddRule(new CSSStyleRule());
+                SwitchTo(CssState.InSelector);
+                InSelector(token);
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// State that is called once in the head of an unknown @ rule.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InUnknown(CssToken token)
+        {
+            switch (token.Type)
+            {
+                case CssTokenType.Semicolon:
+                    CurrentRuleAs<CSSUnknownRule>().SetInstruction(buffer.ToPool());
+                    SwitchTo(CssState.Data);
+                    return CloseRule();
+                case CssTokenType.CurlyBracketOpen:
+                    CurrentRuleAs<CSSUnknownRule>().SetCondition(buffer.ToPool());
+                    SwitchTo(CssState.Data);
+                    break;
+                default:
+                    buffer.Append(token.ToValue());
+                    break;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// State that is called once we are in a CSS selector.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InSelector(CssToken token)
+        {
+            if (token.Type == CssTokenType.CurlyBracketOpen)
+            {
+                var rule = CurrentRule as ICssSelector;
+
+                if (rule != null)
+                    rule.Selector = selector.Result;
+
+                SwitchTo(CurrentRule is CSSStyleRule ? CssState.InDeclaration : CssState.Data);
+            }
+            else if (token.Type == CssTokenType.CurlyBracketClose)
+                return false;
+            else
+                selector.Apply(token);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Called before the property name has been detected.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InDeclaration(CssToken token)
+        {
+            if (token.Type == CssTokenType.CurlyBracketClose)
+            {
+                CloseProperty();
+                SwitchTo(CurrentRule is CSSKeyframeRule ? CssState.KeyframesData : CssState.Data);
+                return CloseRule();
+            }
+            else if (token.Type == CssTokenType.Ident)
+            {
+                AddDeclaration(CSSProperty.Create(((CssKeywordToken)token).Data));
+                SwitchTo(CssState.AfterProperty);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// After instruction rules a semicolon is required.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean AfterInstruction(CssToken token)
+        {
+            if (token.Type == CssTokenType.Semicolon)
+            {
+                SwitchTo(CssState.Data);
+                return CloseRule();
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// In the condition text of a supports rule.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InCondition(CssToken token)
+        {
+            switch (token.Type)
+            {
+                case CssTokenType.CurlyBracketOpen:
+                    CurrentRuleAs<CSSSupportsRule>().ConditionText = buffer.ToPool();
+                    SwitchTo(CssState.Data);
+                    break;
+                default:
+                    buffer.Append(token.ToValue());
+                    break;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Called before a prefix has been found for the namespace rule.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean BeforePrefix(CssToken token)
+        {
+            if (token.Type == CssTokenType.Ident)
+            {
+                CurrentRuleAs<CSSNamespaceRule>().Prefix = ((CssKeywordToken)token).Data;
+                SwitchTo(CssState.AfterNamespacePrefix);
+                return true;
+            }
+
+            SwitchTo(CssState.AfterInstruction);
+            return AfterInstruction(token);
+        }
+
+        /// <summary>
+        /// Called before a namespace has been found for the namespace rule.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean BeforeNamespace(CssToken token)
+        {
+            SwitchTo(CssState.AfterInstruction);
+
+            if (token.Type == CssTokenType.String)
+            {
+                CurrentRuleAs<CSSNamespaceRule>().NamespaceURI = ((CssStringToken)token).Data;
+                return true;
+            }
+
+            return AfterInstruction(token);
+        }
+
+        /// <summary>
+        /// Before a charset string has been found.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean BeforeCharset(CssToken token)
+        {
+            SwitchTo(CssState.AfterInstruction);
+
+            if (token.Type == CssTokenType.String)
+            {
+                CurrentRuleAs<CSSCharsetRule>().Encoding = ((CssStringToken)token).Data;
+                return true;
+            }
+
+            return AfterInstruction(token);
+        }
+
+        /// <summary>
+        /// Before an URL has been found for the import rule.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean BeforeImport(CssToken token)
+        {
+            if (token.Type == CssTokenType.String || token.Type == CssTokenType.Url)
+            {
+                CurrentRuleAs<CSSImportRule>().Href = ((CssStringToken)token).Data;
+                SwitchTo(CssState.InMediaList);
+                return true;
+            }
+
+            SwitchTo(CssState.AfterInstruction);
+            return false;
+        }
+
+        /// <summary>
+        /// Called before the property separating colon has been seen.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean AfterProperty(CssToken token)
+        {
+            if (token.Type == CssTokenType.Colon)
+            {
+                fraction = false;
+                SwitchTo(CssState.BeforeValue);
+                return true;
+            }
+            else if (token.Type == CssTokenType.Semicolon || token.Type == CssTokenType.CurlyBracketClose)
+                AfterValue(token);
+
+            return false;
+        }
+
+        /// <summary>
+        /// Called before any token in the value regime had been seen.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean BeforeValue(CssToken token)
+        {
+            if (token.Type == CssTokenType.Semicolon)
+                SwitchTo(CssState.InDeclaration);
+            else if (token.Type == CssTokenType.CurlyBracketClose)
+                InDeclaration(token);
+            else
+            {
+                SwitchTo(CssState.InSingleValue);
+                return InSingleValue(token);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Called when a value has to be computed.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InSingleValue(CssToken token)
+        {
+            switch (token.Type)
+            {
+                case CssTokenType.Dimension: // e.g. "3px"
+                    return AddValue(new CSSPrimitiveValue(((CssUnitToken)token).Unit, ((CssUnitToken)token).Data));
+                case CssTokenType.Hash:// e.g. "#ABCDEF"
+                    return InSingleValueHexColor(((CssKeywordToken)token).Data);
+                case CssTokenType.Delim:// e.g. "#"
+                    return InSingleValueDelim((CssDelimToken)token);
+                case CssTokenType.Ident: // e.g. "auto"
+                    return InSingleValueIdent((CssKeywordToken)token);
+                case CssTokenType.String:// e.g. "'i am a string'"
+                    return AddValue(new CSSPrimitiveValue(CssUnit.String, ((CssStringToken)token).Data));
+                case CssTokenType.Url:// e.g. "url('this is a valid URL')"
+                    return AddValue(new CSSPrimitiveValue(CssUnit.Uri, ((CssStringToken)token).Data));
+                case CssTokenType.Percentage: // e.g. "5%"
+                    return AddValue(new CSSPrimitiveValue(CssUnit.Percentage, ((CssUnitToken)token).Data));
+                case CssTokenType.Number: // e.g. "173"
+                    return AddValue(new CSSPrimitiveValue(CssUnit.Number, ((CssNumberToken)token).Data));
+                case CssTokenType.Whitespace: // e.g. " "
+                    SwitchTo(CssState.InValueList);
+                    return true;
+                case CssTokenType.Function: //e.g. rgba(...)
+                    function.Push(new FunctionBuffer(((CssKeywordToken)token).Data));
+                    SwitchTo(CssState.InFunction);
+                    return true;
+                case CssTokenType.Comma: // e.g. ","
+                    SwitchTo(CssState.InValuePool);
+                    return true;
+                case CssTokenType.Semicolon: // e.g. ";"
+                case CssTokenType.CurlyBracketClose: // e.g. "}"
+                    return AfterValue(token);
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Gathers a value inside a function.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InValueFunction(CssToken token)
+        {
+            switch (token.Type)
+            {
+                case CssTokenType.RoundBracketClose:
+                    SwitchTo(CssState.InSingleValue);
+                    return AddValue(function.Pop().Done());
+                case CssTokenType.Comma:
+                    function.Peek().Include();
+                    return true;
+                default:
+                    return InSingleValue(token);
+            }
+        }
+
+        /// <summary>
+        /// Called when a new value is seen from the zero-POV (whitespace seen previously).
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InValueList(CssToken token)
+        {
+            if (token.Type == CssTokenType.Semicolon || token.Type == CssTokenType.CurlyBracketClose)
+                AfterValue(token);
+            else if (token.Type == CssTokenType.Comma)
+                SwitchTo(CssState.InValuePool);
+            else
+            {
+                //TDO
+                SwitchTo(CssState.InSingleValue);
+                return InSingleValue(token);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Called when a new value is seen from the zero-POV (comma seen previously).
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InValuePool(CssToken token)
+        {
+            if (token.Type == CssTokenType.Semicolon || token.Type == CssTokenType.CurlyBracketClose)
+                AfterValue(token);
+            else
+            {
+                //TODO
+                SwitchTo(CssState.InSingleValue);
+                return InSingleValue(token);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Called if a # sign has been found.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InHexValue(CssToken token)
+        {
+            switch (token.Type)
+            {
+                case CssTokenType.Number:
+                case CssTokenType.Dimension:
+                case CssTokenType.Ident:
+                    var rest = token.ToValue();
+
+                    if (buffer.Length + rest.Length <= 6)
+                    {
+                        buffer.Append(rest);
+                        return true;
+                    }
+
+                    break;
+            }
+
+            var s = buffer.ToPool();
+            InSingleValueHexColor(buffer.ToString());
+            SwitchTo(CssState.InSingleValue);
+            return InSingleValue(token);
+        }
+
+        /// <summary>
+        /// Called after the value is known to be over.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean AfterValue(CssToken token)
+        {
+            if (token.Type == CssTokenType.Semicolon)
+            {
+                CloseProperty();
+                SwitchTo(CssState.InDeclaration);
+                return true;
+            }
+            else if (token.Type == CssTokenType.CurlyBracketClose)
+                return InDeclaration(token);
+
+            return false;
+        }
+
+        /// <summary>
+        /// Called once an important instruction is expected.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean ValueImportant(CssToken token)
+        {
+            if (token.Type == CssTokenType.Ident && ((CssKeywordToken)token).Data == "important")
+            {
+                SwitchTo(CssState.AfterValue);
+                property.Important = true;
+                return true;
+            }
+
+            return AfterValue(token);
+        }
+
+        /// <summary>
+        /// Before the name of an @keyframes rule has been detected.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean BeforeKeyframesName(CssToken token)
+        {
+            SwitchTo(CssState.BeforeKeyframesData);
+
+            if (token.Type == CssTokenType.Ident)
+            {
+                CurrentRuleAs<CSSKeyframesRule>().Name = ((CssKeywordToken)token).Data;
+                return true;
+            }
+            else if (token.Type == CssTokenType.CurlyBracketOpen)
+            {
+                SwitchTo(CssState.KeyframesData);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Before the curly bracket of an @keyframes rule has been seen.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean BeforeKeyframesData(CssToken token)
+        {
+            if (token.Type == CssTokenType.CurlyBracketOpen)
+            {
+                SwitchTo(CssState.BeforeKeyframesData);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Called in the @keyframes rule.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean KeyframesData(CssToken token)
+        {
+            if (token.Type == CssTokenType.CurlyBracketClose)
+            {
+                SwitchTo(CssState.Data);
+                return CloseRule();
+            }
+            else
+            {
+                buffer = Pool.NewStringBuilder();
+                return InKeyframeText(token);
+            }
+        }
+
+        /// <summary>
+        /// Called in the text for a frame in the @keyframes rule.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InKeyframeText(CssToken token)
+        {
+            if (token.Type == CssTokenType.CurlyBracketOpen)
+            {
+                var frame = new CSSKeyframeRule();
+                frame.KeyText = buffer.ToPool();
+                AddRule(frame);
+                SwitchTo(CssState.InDeclaration);
+                return true;
+            }
+            else if (token.Type == CssTokenType.CurlyBracketClose)
+            {
+                buffer.ToPool();
+                KeyframesData(token);
+                return false;
+            }
+
+            buffer.Append(token.ToValue());
+            return true;
+        }
+
+        /// <summary>
+        /// Called before a document function has been found.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean BeforeDocumentFunction(CssToken token)
+        {
+            switch (token.Type)
+            {
+                case CssTokenType.Url:
+                    CurrentRuleAs<CSSDocumentRule>().Conditions.Add(Tuple.Create(CSSDocumentRule.DocumentFunction.Url, ((CssStringToken)token).Data));
+                    break;
+                case CssTokenType.UrlPrefix:
+                    CurrentRuleAs<CSSDocumentRule>().Conditions.Add(Tuple.Create(CSSDocumentRule.DocumentFunction.UrlPrefix, ((CssStringToken)token).Data));
+                    break;
+                case CssTokenType.Domain:
+                    CurrentRuleAs<CSSDocumentRule>().Conditions.Add(Tuple.Create(CSSDocumentRule.DocumentFunction.Domain, ((CssStringToken)token).Data));
+                    break;
+                case CssTokenType.Function:
+                    if (String.Compare(((CssKeywordToken)token).Data, "regexp", StringComparison.OrdinalIgnoreCase) == 0)
+                    {
+                        SwitchTo(CssState.InDocumentFunction);
+                        return true;
+                    }
+                    SwitchTo(CssState.AfterDocumentFunction);
+                    return false;
+                default:
+                    SwitchTo(CssState.Data);
+                    return false;
+            }
+
+            SwitchTo(CssState.BetweenDocumentFunctions);
+            return true;
+        }
+
+        /// <summary>
+        /// Called before the argument of a document function has been found.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InDocumentFunction(CssToken token)
+        {
+            SwitchTo(CssState.AfterDocumentFunction);
+
+            if (token.Type == CssTokenType.String)
+            {
+                CurrentRuleAs<CSSDocumentRule>().Conditions.Add(Tuple.Create(CSSDocumentRule.DocumentFunction.RegExp, ((CssStringToken)token).Data));
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Called after the arguments of a document function has been found.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean AfterDocumentFunction(CssToken token)
+        {
+            SwitchTo(CssState.BetweenDocumentFunctions);
+            return token.Type == CssTokenType.RoundBracketClose;
+        }
+
+        /// <summary>
+        /// Called after a function has been completed.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean BetweenDocumentFunctions(CssToken token)
+        {
+            if (token.Type == CssTokenType.Comma)
+            {
+                SwitchTo(CssState.BeforeDocumentFunction);
+                return true;
+            }
+            else if (token.Type == CssTokenType.CurlyBracketOpen)
+            {
+                SwitchTo(CssState.Data);
+                return true;
+            }
+
+            SwitchTo(CssState.Data);
+            return false;
+        }
+
+        /// <summary>
+        /// Before any medium has been found for the @media or @import rule.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InMediaList(CssToken token)
+        {
+            if (token.Type == CssTokenType.Semicolon)
+            {
+                CloseRule();
+                SwitchTo(CssState.Data);
+                return true;
+            }
+
+            buffer = Pool.NewStringBuilder();
+            SwitchTo(CssState.InMediaValue);
+            return InMediaValue(token);
+        }
+
+        /// <summary>
+        /// Scans the current medium for the @media or @import rule.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean InMediaValue(CssToken token)
+        {
+            switch (token.Type)
+            {
+                case CssTokenType.CurlyBracketOpen:
+                case CssTokenType.Semicolon:
+                    {
+                        var container = CurrentRule as ICssMedia;
+                        var s = buffer.ToPool();
+
+                        if (container != null)
+                            container.Media.AppendMedium(s);
+
+                        if (CurrentRule is CSSImportRule)
+                            return AfterInstruction(token);
+
+                        SwitchTo(CssState.Data);
+                        return token.Type == CssTokenType.CurlyBracketClose;
+                    }
+                case CssTokenType.Comma:
+                    {
+                        var container = CurrentRule as ICssMedia;
+
+                        if (container != null)
+                            container.Media.AppendMedium(buffer.ToString());
+
+                        buffer.Clear();
+                        return true;
+                    }
+                case CssTokenType.Whitespace:
+                    {
+                        buffer.Append(' ');
+                        return true;
+                    }
+                default:
+                    {
+                        buffer.Append(token.ToValue());
+                        return true;
+                    }
+            }
+        }
+
+        #endregion
+
+        #region Substates
+
+        /// <summary>
+        /// Called in a value - a delimiter has been found.
+        /// </summary>
+        /// <param name="token">The current delim token.</param>
+        /// <returns>The status.</returns>
+        Boolean InSingleValueDelim(CssDelimToken token)
+        {
+            switch (token.Data)
+            {
+                case Specification.EM:
+                    SwitchTo(CssState.ValueImportant);
+                    return true;
+                case Specification.NUM:
+                    buffer = Pool.NewStringBuilder();
+                    SwitchTo(CssState.InHexValue);
+                    return true;
+                case Specification.SOLIDUS:
+                    fraction = true;
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Called in a value - an identifier has been found.
+        /// </summary>
+        /// <param name="token">The current keyword token.</param>
+        /// <returns>The status.</returns>
+        Boolean InSingleValueIdent(CssKeywordToken token)
+        {
+            if (token.Data == "inherit")
+            {
+                property.Value = CSSValue.Inherit;
+                SwitchTo(CssState.AfterValue);
+                return true;
+            }
+
+            return AddValue(new CSSPrimitiveValue(CssUnit.Ident, token.Data));
+        }
+
+        /// <summary>
+        /// Called in a value - a hash (probably hex) value has been found.
+        /// </summary>
+        /// <param name="token">The value of the token.</param>
+        /// <returns>The status.</returns>
+        Boolean InSingleValueHexColor(String color)
+        {
+            CSSColor value;
+
+            if (CSSColor.TryFromHex(color, out value))
+                return AddValue(new CSSPrimitiveValue(value));
+
+            return false;
+        }
+
+        #endregion
+
+        #region Rule management
+
+        /// <summary>
+        /// Adds the new value to the current value (or replaces it).
+        /// </summary>
+        /// <param name="value">The value to add.</param>
+        /// <returns>The status.</returns>
+        Boolean AddValue(CSSValue value)
+        {
+            if (fraction)
+            {
+                if (this.value != null)
+                {
+                    value = new CSSPrimitiveValue(CssUnit.Unknown, this.value.ToCss() + "/" + value.ToCss());
+                    this.value = null;
+                }
+
+                fraction = false;
+            }
+
+            if (function.Count > 0)
+                function.Peek().Arguments.Add(value);
+            else if (this.value == null)
+                this.value = value;
+            else
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Closes a property.
+        /// </summary>
+        void CloseProperty()
+        {
+            if (property != null)
+                property.Value = value;
+
+            value = null;
+            property = null;
+        }
+
+        /// <summary>
+        /// Closes the current rule (if any).
+        /// </summary>
+        /// <returns>The status.</returns>
+        Boolean CloseRule()
+        {
+            if (open.Count > 0)
+            {
+                open.Pop();
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Adds a new rule.
+        /// </summary>
+        /// <param name="rule">The new rule.</param>
+        void AddRule(CSSRule rule)
+        {
+            rule.ParentStyleSheet = sheet;
+
+            if (open.Count > 0)
+            {
+                var container = open.Peek() as ICssRules;
+
+                if (container != null)
+                {
+                    container.CssRules.List.Add(rule);
+                    rule.ParentRule = open.Peek();
+                }
+            }
+            else
+                sheet.CssRules.List.Add(rule);
+
+            open.Push(rule);
+        }
+
+        /// <summary>
+        /// Adds a declaration.
+        /// </summary>
+        /// <param name="property">The new property.</param>
+        void AddDeclaration(CSSProperty property)
+        {
+            this.property = property;
+            var rule = CurrentRule as IStyleDeclaration;
+
+            if (rule != null)
+                rule.Style.List.Add(property);
+        }
+
+        #endregion
+
+        #region Helpers
+
+        /// <summary>
+        /// Gets the current rule casted to the given type.
+        /// </summary>
+        T CurrentRuleAs<T>()
+            where T : CSSRule
+        {
+            if (open.Count > 0)
+                return open.Peek() as T;
+
+            return default(T);
+        }
+
+        /// <summary>
+        /// Switches the current state to the given one.
+        /// </summary>
+        /// <param name="newState">The state to switch to.</param>
+        void SwitchTo(CssState newState)
+        {
+            switch (newState)
+            {
+                case CssState.InSelector:
+                    tokenizer.IgnoreComments = true;
+                    tokenizer.IgnoreWhitespace = false;
+                    selector.Reset();
+                    selector.IgnoreErrors = skipExceptions;
+                    break;
+
+                case CssState.InHexValue:
+                case CssState.InUnknown:
+                case CssState.InCondition:
+                case CssState.InSingleValue:
+                case CssState.InMediaValue:
+                    tokenizer.IgnoreComments = true;
+                    tokenizer.IgnoreWhitespace = false;
+                    break;
+
+                default:
+                    tokenizer.IgnoreComments = true;
+                    tokenizer.IgnoreWhitespace = true;
+                    break;
+            }
+
+            state = newState;
+        }
+
+        /// <summary>
+        /// The kernel that is pulling the tokens into the parser.
+        /// </summary>
+        void Kernel()
+        {
+            var tokens = tokenizer.Tokens;
+
+            foreach (var token in tokens)
+            {
+                if (General(token) == false)
+                    RaiseErrorOccurred(ErrorCode.InputUnexpected);
+            }
+
+            if (property != null)
+                General(CssSpecialCharacter.Semicolon);
+
+            selector.ToPool();
+        }
+
+        /// <summary>
+        /// Examines the token by using the current state.
+        /// </summary>
+        /// <param name="token">The current token.</param>
+        /// <returns>The status.</returns>
+        Boolean General(CssToken token)
+        {
+            switch (state)
+            {
+                case CssState.Data:
+                    return Data(token);
+                case CssState.InSelector:
+                    return InSelector(token);
+                case CssState.InDeclaration:
+                    return InDeclaration(token);
+                case CssState.AfterProperty:
+                    return AfterProperty(token);
+                case CssState.BeforeValue:
+                    return BeforeValue(token);
+                case CssState.InValuePool:
+                    return InValuePool(token);
+                case CssState.InValueList:
+                    return InValueList(token);
+                case CssState.InSingleValue:
+                    return InSingleValue(token);
+                case CssState.ValueImportant:
+                    return ValueImportant(token);
+                case CssState.AfterValue:
+                    return AfterValue(token);
+                case CssState.InMediaList:
+                    return InMediaList(token);
+                case CssState.InMediaValue:
+                    return InMediaValue(token);
+                case CssState.BeforeImport:
+                    return BeforeImport(token);
+                case CssState.AfterInstruction:
+                    return AfterInstruction(token);
+                case CssState.BeforeCharset:
+                    return BeforeCharset(token);
+                case CssState.BeforeNamespacePrefix:
+                    return BeforePrefix(token);
+                case CssState.AfterNamespacePrefix:
+                    return BeforeNamespace(token);
+                case CssState.InCondition:
+                    return InCondition(token);
+                case CssState.InUnknown:
+                    return InUnknown(token);
+                case CssState.InKeyframeText:
+                    return InKeyframeText(token);
+                case CssState.BeforeDocumentFunction:
+                    return BeforeDocumentFunction(token);
+                case CssState.InDocumentFunction:
+                    return InDocumentFunction(token);
+                case CssState.AfterDocumentFunction:
+                    return AfterDocumentFunction(token);
+                case CssState.BetweenDocumentFunctions:
+                    return BetweenDocumentFunctions(token);
+                case CssState.BeforeKeyframesName:
+                    return BeforeKeyframesName(token);
+                case CssState.BeforeKeyframesData:
+                    return BeforeKeyframesData(token);
+                case CssState.KeyframesData:
+                    return KeyframesData(token);
+                case CssState.InHexValue:
+                    return InHexValue(token);
+                case CssState.InFunction:
+                    return InValueFunction(token);
+                default:
+                    return false;
+            }
+        }
+
+        #endregion
+
+        #region Public static methods
+
+        /// <summary>
+        /// Takes a string and transforms it into a selector object.
+        /// </summary>
+        /// <param name="selector">The string to parse.</param>
+        /// <returns>The Selector object.</returns>
+        public static Selector ParseSelector(String selector)
+        {
+            var tokenizer = new CssTokenizer(new SourceManager(selector));
+            var tokens = tokenizer.Tokens;
+            var selctor = Pool.NewSelectorConstructor();
+
+            foreach (var token in tokens)
+                selctor.Apply(token);
+
+            var result = selctor.Result;
+            selctor.ToPool();
+            return result;
+        }
+
+        /// <summary>
+        /// Takes a string and transforms it into a CSS stylesheet.
+        /// </summary>
+        /// <param name="stylesheet">The string to parse.</param>
+        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
+        /// <returns>The CSSStyleSheet object.</returns>
+        public static CSSStyleSheet ParseStyleSheet(String stylesheet, Boolean quirksMode = false)
+        {
+            var parser = new CssParser(stylesheet);
+            parser.IsQuirksMode = quirksMode;
+            return parser.Result;
+        }
+
+        /// <summary>
+        /// Takes a string and transforms it into a CSS rule.
+        /// </summary>
+        /// <param name="rule">The string to parse.</param>
+        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
+        /// <returns>The CSSRule object.</returns>
+        public static CSSRule ParseRule(String rule, Boolean quirksMode = false)
+        {
+            var parser = new CssParser(rule);
+            parser.skipExceptions = false;
+            parser.IsQuirksMode = quirksMode;
+            parser.Parse();
+
+            if (parser.sheet.CssRules.Length > 0)
+                return parser.sheet.CssRules[0];
+
+            return null;
+        }
+
+        /// <summary>
+        /// Takes a string and transforms it into CSS declarations.
+        /// </summary>
+        /// <param name="declarations">The string to parse.</param>
+        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
+        /// <returns>The CSSStyleDeclaration object.</returns>
+        public static CSSStyleDeclaration ParseDeclarations(String declarations, Boolean quirksMode = false)
+        {
+            var decl = new CSSStyleDeclaration();
+            AppendDeclarations(decl, declarations, quirksMode);
+            return decl;
+        }
+
+        /// <summary>
+        /// Takes a string and transforms it into a CSS declaration (CSS property).
+        /// </summary>
+        /// <param name="declarations">The string to parse.</param>
+        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
+        /// <returns>The CSSProperty object.</returns>
+        public static CSSProperty ParseDeclaration(String declarations, Boolean quirksMode = false)
+        {
+            var parser = new CssParser(declarations);
+            parser.state = CssState.InDeclaration;
+            parser.IsQuirksMode = quirksMode;
+            parser.skipExceptions = false;
+            parser.Parse();
+            return parser.property;
+        }
+
+        /// <summary>
+        /// Takes a string and transforms it into a CSS value.
+        /// </summary>
+        /// <param name="source">The string to parse.</param>
+        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
+        /// <returns>The CSSValue object.</returns>
+        public static CSSValue ParseValue(String source, Boolean quirksMode = false)
+        {
+            var parser = new CssParser(source);
+            var property = new CSSProperty(String.Empty);
+            parser.property = property;
+            parser.IsQuirksMode = quirksMode;
+            parser.skipExceptions = false;
+            parser.state = CssState.BeforeValue;
+            parser.Parse();
+            return property.Value;
+        }
+
+        #endregion
+
+        #region Internal static methods
+
+        /// <summary>
+        /// Takes a string and transforms it into a list of CSS values.
+        /// </summary>
+        /// <param name="source">The string to parse.</param>
+        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
+        /// <returns>The CSSValueList object.</returns>
+        internal static CSSValueList ParseValueList(String source, Boolean quirksMode = false)
+        {
+            var parser = new CssParser(source);
+            var list = new CSSValueList();
+            var property = new CSSProperty(String.Empty);
+            property.Value = list;
+            parser.property = property;
+            parser.IsQuirksMode = quirksMode;
+            parser.skipExceptions = false;
+            parser.state = CssState.InValueList;
+            parser.Parse();
+            return list;
+        }
+
+        /// <summary>
+        /// Takes a comma separated string and transforms it into a list of CSS values.
+        /// </summary>
+        /// <param name="source">The string to parse.</param>
+        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
+        /// <returns>The CSSValueList object.</returns>
+        internal static CSSValuePool ParseMultipleValues(String source, Boolean quirksMode = false)
+        {
+            var parser = new CssParser(source);
+            var pool = new CSSValuePool();
+            var property = new CSSProperty(String.Empty);
+            property.Value = pool;
+            parser.property = property;
+            parser.IsQuirksMode = quirksMode;
+            parser.skipExceptions = false;
+            parser.state = CssState.InValuePool;
+            parser.Parse();
+            return pool;
+        }
+
+        /// <summary>
+        /// Takes a string and transforms it into a CSS keyframe rule.
+        /// </summary>
+        /// <param name="rule">The string to parse.</param>
+        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
+        /// <returns>The CSSKeyframeRule object.</returns>
+        internal static CSSKeyframeRule ParseKeyframeRule(String rule, Boolean quirksMode = false)
+        {
+            var parser = new CssParser(rule);
+            var keyframe = new CSSKeyframeRule();
+            parser.AddRule(keyframe);
+            parser.IsQuirksMode = quirksMode;
+            parser.skipExceptions = false;
+            parser.state = CssState.InKeyframeText;
+            parser.Parse();
+            return keyframe;
+        }
+
+        /// <summary>
+        /// Takes a string and appends all rules to the given list of properties.
+        /// </summary>
+        /// <param name="list">The list of css properties to append to.</param>
+        /// <param name="declarations">The string to parse.</param>
+        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
+        internal static void AppendDeclarations(CSSStyleDeclaration list, String declarations, Boolean quirksMode = false)
+        {
+            var parser = new CssParser(declarations);
+            parser.IsQuirksMode = quirksMode;
+            parser.skipExceptions = false;
+
+            if (list.ParentRule != null)
+                parser.AddRule(list.ParentRule);
+            else
+                parser.AddRule(new CSSStyleRule(list));
+
+            parser.state = CssState.InDeclaration;
+            parser.Parse();
+        }
+
+        #endregion
+
+        #region State Enumeration
+
+        /// <summary>
+        /// The enumeration with possible state values.
+        /// </summary>
+        enum CssState
+        {
+            Data,
+            InSelector,
+            InDeclaration,
+            AfterProperty,
+            BeforeValue,
+            InValuePool,
+            InValueList,
+            InSingleValue,
+            InMediaList,
+            InMediaValue,
+            BeforeImport,
+            BeforeCharset,
+            BeforeNamespacePrefix,
+            AfterNamespacePrefix,
+            AfterInstruction,
+            InCondition,
+            BeforeKeyframesName,
+            BeforeKeyframesData,
+            KeyframesData,
+            InKeyframeText,
+            BeforeDocumentFunction,
+            InDocumentFunction,
+            AfterDocumentFunction,
+            BetweenDocumentFunctions,
+            InUnknown,
+            ValueImportant,
+            AfterValue,
+            InHexValue,
+            InFunction
+        }
+
+        /// <summary>
+        /// A buffer for functions.
+        /// </summary>
+        class FunctionBuffer
+        {
+            #region Members
+
+            String name;
+            List<CSSValue> arguments;
+            CSSValue value;
+
+            #endregion
+
+            #region ctor
+
+            internal FunctionBuffer(String name)
+            {
+                this.arguments = new List<CSSValue>();
+                this.name = name;
+            }
+
+            #endregion
+
+            #region Properties
+
+            public List<CSSValue> Arguments
+            {
+                get { return arguments; }
+            }
+
+            public CSSValue Value
+            {
+                get { return value; }
+                set { this.value = value; }
+            }
+
+            #endregion
+
+            #region Methods
+
+            public void Include()
+            {
+                if (value != null)
+                    arguments.Add(value);
+
+                value = null;
+            }
+
+            public CSSValue Done()
+            {
+                Include();
+                return CSSFunction.Create(name, arguments);
+            }
+
+            #endregion
+        }
+
+        #endregion
+    }
+}

Source/External/ExCSS/StyleSheet.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using ExCSS.Model.Extensions;
+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    public sealed class StyleSheet
+    {
+        private readonly List<RuleSet> _rules;
+
+        public StyleSheet()
+        {
+            _rules = new List<RuleSet>();
+            Errors = new List<StylesheetParseError>();
+        }
+
+        public List<RuleSet> Rules
+        {
+            get { return _rules; }
+        }
+
+        public StyleSheet RemoveRule(int index)
+        {
+            if (index >= 0 && index < _rules.Count)
+            {
+                _rules.RemoveAt(index);
+            }
+
+            return this;
+        }
+
+        public StyleSheet InsertRule(string rule, int index)
+        {
+            if (index < 0 || index > _rules.Count)
+            {
+                return this;
+            }
+
+            var value = Parser.ParseRule(rule);
+            _rules.Insert(index, value);
+
+            return this;
+        }
+
+        public IList<StyleRule> StyleRules
+        {
+            get
+            {
+                return Rules.Where(r => r is StyleRule).Cast<StyleRule>().ToList();
+            }
+        } 
+
+        public IList<CharacterSetRule> CharsetDirectives
+        {
+            get
+            {
+                return GetDirectives<CharacterSetRule>(RuleType.Charset);
+            }
+        }
+
+        public IList<ImportRule> ImportDirectives
+        {
+            get
+            {
+                return GetDirectives<ImportRule>(RuleType.Import);
+            }
+        }
+
+        public IList<FontFaceRule> FontFaceDirectives
+        {
+            get
+            {
+                return GetDirectives<FontFaceRule>(RuleType.FontFace);
+            }
+        }
+
+        public IList<KeyframesRule> KeyframeDirectives
+        {
+            get
+            {
+                return GetDirectives<KeyframesRule>(RuleType.Keyframes);
+            }
+        }
+
+        public IList<MediaRule> MediaDirectives
+        {
+            get
+            {
+                return GetDirectives<MediaRule>(RuleType.Media);
+
+            }
+        }
+
+        public IList<PageRule> PageDirectives
+        {
+            get
+            {
+                return GetDirectives<PageRule>(RuleType.Page);
+
+            }
+        }
+
+        public IList<SupportsRule> SupportsDirectives
+        {
+            get
+            {
+                return GetDirectives<SupportsRule>(RuleType.Supports);
+            }
+        }
+
+        public IList<NamespaceRule> NamespaceDirectives
+        {
+            get
+            {
+                return GetDirectives<NamespaceRule>(RuleType.Namespace);
+            }
+        }
+
+        private IList<T> GetDirectives<T>(RuleType ruleType)
+        {
+            return Rules.Where(r => r.RuleType == ruleType).Cast<T>().ToList();
+        }
+
+        public List<StylesheetParseError> Errors { get; private set; }
+
+        public override string ToString()
+        {
+            return ToString(false);
+        }
+
+        public string ToString(bool friendlyFormat, int indentation = 0)
+        {
+            var builder = new StringBuilder();
+
+            foreach (var rule in _rules)
+            {
+                builder.Append(rule.ToString(friendlyFormat, indentation).TrimStart() + (friendlyFormat ? Environment.NewLine : ""));
+            }
+
+            return builder.TrimFirstLine().TrimLastLine().ToString();
+        }
+    }
+}

Source/External/ExCSS/StylesheetParseError.cs

+
+namespace ExCSS
+{
+    public sealed class StylesheetParseError
+    {
+        public StylesheetParseError(ParserError error, string errorMessage, int line, int column)
+        {
+            ParserError = error;
+            Message = errorMessage;
+            Line = line;
+            Column = column;
+        }
+
+        public ParserError ParserError { get; set; }
+
+        public int Line{get;set;}
+
+        public int Column{get;set;}
+
+        public string Message{get;private set;}
+
+        public override string ToString()
+        {
+            return string.Format("Line {0}, Column {1}: {2}.", Line, Column, Message);
+        }
+    }
+}
\ No newline at end of file

Source/External/ExCSS/StylesheetReader.cs

+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using ExCSS.Model;
+
+namespace ExCSS
+{
+    internal class StylesheetReader
+    {
+        private int _insertion;
+        private readonly Stack<int> _collengths;
+        private TextReader _reader;
+        private readonly StringBuilder _buffer;
+        private bool _lineWithReturn;
+
+        StylesheetReader()
+        {
+            _buffer = new StringBuilder();
+            _collengths = new Stack<int>();
+            Column = 1;
+            Line = 1;
+        }
+
+        internal StylesheetReader(string styleText) : this()
+        {
+            _reader = new StringReader(styleText);
+            ReadCurrent();
+        }
+
+        internal StylesheetReader(Stream styleStream) : this()
+        {
+            _reader = new StreamReader(styleStream, true);
+            ReadCurrent();
+        }
+
+        internal bool IsBeginning
+        {
+            get { return _insertion < 2; }
+        }
+
+        internal int Line { get; private set; }
+
+        internal int Column { get; private set; }
+
+        internal bool IsEnded { get; private set; }
+
+        internal bool IsEnding
+        {
+            get { return Current == Specification.EndOfFile; }
+        }
+
+        internal char Current { get; private set; }
+
+        internal char Next
+        {
+            get
+            {
+                Advance();
+
+                return Current;
+            }
+        }
+
+        internal char Previous
+        {
+            get
+            {
+                Back();
+
+                return Current;
+            }
+        }
+
+        internal void Advance()
+        {
+            if (!IsEnding)
+            {
+                AdvanceUnsafe();
+            }
+            else if (!IsEnded)
+            {
+                IsEnded = true;
+            }
+        }
+
+        internal void Advance(int positions)
+        {
+            while (positions-- > 0 && !IsEnding)
+            {
+                AdvanceUnsafe();
+            }
+        }
+
+        internal void Back()
+        {
+            IsEnded = false;
+
+            if (!IsBeginning)
+            {
+                BackUnsafe();
+            }
+        }
+
+        internal void Back(int positions)
+        {
+            IsEnded = false;
+
+            while (positions-- > 0 && !IsBeginning)
+            {
+                BackUnsafe();
+            }
+        }
+
+        private void ReadCurrent()
+        {
+            if (_insertion < _buffer.Length)
+            {
+                Current = _buffer[_insertion];
+                _insertion++;
+                return;
+            }
+
+            var nextPosition = _reader.Read();
+            Current = nextPosition == -1 ? Specification.EndOfFile : (char)nextPosition;
+
+            if (Current == Specification.CarriageReturn)
+            {
+                Current = Specification.LineFeed;
+                _lineWithReturn = true;
+            }
+            else if (_lineWithReturn)
+            {
+                _lineWithReturn = false;
+
+                if (Current == Specification.LineFeed)
+                {
+                    ReadCurrent();
+                    return;
+                }
+            }
+
+            _buffer.Append(Current);
+            _insertion++;
+        }
+
+        private void AdvanceUnsafe()
+        {
+            if (Current.IsLineBreak())
+            {
+                _collengths.Push(Column);
+                Column = 1;
+                Line++;
+            }
+            else
+            {
+                Column++;
+            }
+
+            ReadCurrent();
+        }
+
+        private void BackUnsafe()
+        {
+            _insertion--;
+
+            if (_insertion == 0)
+            {
+                Column = 0;
+                Current = Specification.Null;
+                return;
+            }
+
+            Current = _buffer[_insertion - 1];
+
+            if (Current.IsLineBreak())
+            {
+                Column = _collengths.Count != 0 ? _collengths.Pop() : 1;
+                Line--;
+            }
+            else
+            {
+                Column--;
+            }
+        }
+    }
+}
\ No newline at end of file

Source/External/Fizzler/Either.cs

+//
+// Copyright (c) 2008 Novell, Inc. (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+namespace Fizzler
+{
+    #region Imports
+
+    using System;
+    using System.Collections.Generic;
+
+    #endregion
+
+    // Adapted from Mono Rocks
+
+    internal abstract class Either<TA, TB> 
+            : IEquatable<Either<TA, TB>>
+    {
+        private Either() {}
+
+        public static Either<TA, TB> A(TA value)
+        {
+            if (value == null) throw new ArgumentNullException("value");
+            return new AImpl(value);
+        }
+
+        public static Either<TA, TB> B(TB value)
+        {
+            if (value == null) throw new ArgumentNullException("value");
+            return new BImpl(value);
+        }
+
+        public override abstract bool Equals(object obj);
+        public abstract bool Equals(Either<TA, TB> obj);
+        public override abstract int GetHashCode();
+        public override abstract string ToString();
+        public abstract TResult Fold<TResult>(Func<TA, TResult> a, Func<TB, TResult> b);
+
+        private sealed class AImpl : Either<TA, TB>
+        {
+            private readonly TA _value;
+
+            public AImpl(TA value)
+            {
+                _value = value;
+            }
+
+            public override int GetHashCode()
+            {
+                return _value.GetHashCode();
+            }
+
+            public override bool Equals(object obj)
+            {
+                return Equals(obj as AImpl);
+            }
+
+            public override bool Equals(Either<TA, TB> obj)
+            {
+                var a = obj as AImpl;
+                return a != null 
+                    && EqualityComparer<TA>.Default.Equals(_value, a._value);
+            }
+
+            public override TResult Fold<TResult>(Func<TA, TResult> a, Func<TB, TResult> b)
+            {
+                if (a == null) throw new ArgumentNullException("a");
+                if (b == null) throw new ArgumentNullException("b");
+                return a(_value);
+            }
+
+            public override string ToString()
+            {
+                return _value.ToString();
+            }
+        }
+
+        private sealed class BImpl : Either<TA, TB>
+        {
+            private readonly TB _value;
+
+            public BImpl(TB value)
+            {
+                _value = value;
+            }
+
+            public override int GetHashCode()
+            {
+                return _value.GetHashCode();
+            }
+
+            public override bool Equals(object obj)
+            {
+                return Equals(obj as BImpl);
+            }
+
+            public override bool Equals(Either<TA, TB> obj)
+            {
+                var b = obj as BImpl;
+                return b != null 
+                    && EqualityComparer<TB>.Default.Equals(_value, b._value);
+            }
+
+            public override TResult Fold<TResult>(Func<TA, TResult> a, Func<TB, TResult> b)
+            {
+                if (a == null) throw new ArgumentNullException("a");
+                if (b == null) throw new ArgumentNullException("b");
+                return b(_value);
+            }
+
+            public override string ToString()
+            {
+                return _value.ToString();
+            }
+        }
+    }
+}
\ No newline at end of file

Source/External/Fizzler/HumanReadableSelectorGenerator.cs

+#region Copyright and License
+// 
+// Fizzler - CSS Selector Engine for Microsoft .NET Framework
+// Copyright (c) 2009 Atif Aziz, Colin Ramsay. All rights reserved.
+// 
+// This library is free software; you can redistribute it and/or modify it under 
+// the terms of the GNU Lesser General Public License as published by the Free 
+// Software Foundation; either version 3 of the License, or (at your option) 
+// any later version.
+// 
+// This library is distributed in the hope that it will be useful, but WITHOUT 
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 
+// details.
+// 
+// You should have received a copy of the GNU Lesser General Public License 
+// along with this library; if not, write to the Free Software Foundation, Inc., 
+// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
+// 
+#endregion
+
+namespace Fizzler
+{
+    using System;
+
+    /// <summary>
+    /// An <see cref="ISelectorGenerator"/> implementation that generates
+    /// human-readable description of the selector.
+    /// </summary>
+    public class HumanReadableSelectorGenerator : ISelectorGenerator
+    {
+        private int _chainCount;
+
+        /// <summary>
+        /// Initializes the text.
+        /// </summary>
+        public virtual void OnInit()
+        {
+            Text = null;
+        }
+
+        /// <summary>
+        /// Gets the generated human-readable description text.
+        /// </summary>
+        public string Text { get; private set; }
+
+        /// <summary>
+        /// Generates human-readable for a selector in a group.
+        /// </summary>
+        public virtual void OnSelector()
+        {
+            if (string.IsNullOrEmpty(Text))
+                Text = "Take all";
+            else
+                Text += " and select them. Combined with previous, take all";
+        }
+
+        /// <summary>
+        /// Concludes the text.
+        /// </summary>
+        public virtual void OnClose()
+        {
+            Text = Text.Trim();
+            Text += " and select them.";
+        }
+
+        /// <summary>
+        /// Adds to the generated human-readable text.
+        /// </summary>
+        protected void Add(string selector)
+        {
+            if (selector == null) throw new ArgumentNullException("selector");
+            Text += selector;
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this type selector.
+        /// </summary>
+        public void Type(NamespacePrefix prefix, string type)
+        {
+            Add(string.Format(" <{0}> elements", type));
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this universal selector.
+        /// </summary>
+        public void Universal(NamespacePrefix prefix)
+        {
+            Add(" elements");
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this ID selector.
+        /// </summary>
+        public void Id(string id)
+        {
+            Add(string.Format(" with an ID of '{0}'", id));
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this class selector.
+        /// </summary>
+        void ISelectorGenerator.Class(string clazz)
+        {
+            Add(string.Format(" with a class of '{0}'", clazz));
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this attribute selector.
+        /// </summary>
+        public void AttributeExists(NamespacePrefix prefix, string name)
+        {
+            Add(string.Format(" which have attribute {0} defined", name));
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this attribute selector.
+        /// </summary>
+        public void AttributeExact(NamespacePrefix prefix, string name, string value)
+        {
+            Add(string.Format(" which have attribute {0} with a value of '{1}'", name, value));
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this attribute selector.
+        /// </summary>
+        public void AttributeIncludes(NamespacePrefix prefix, string name, string value)
+        {
+            Add(string.Format(" which have attribute {0} that includes the word '{1}'", name, value));
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this attribute selector.
+        /// </summary>
+        public void AttributeDashMatch(NamespacePrefix prefix, string name, string value)
+        {
+            Add(string.Format(" which have attribute {0} with a hyphen separated value matching '{1}'", name, value));
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this attribute selector.
+        /// </summary>
+        public void AttributePrefixMatch(NamespacePrefix prefix, string name, string value)
+        {
+            Add(string.Format(" which have attribute {0} whose value begins with '{1}'", name, value));
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this attribute selector.
+        /// </summary>
+        public void AttributeSuffixMatch(NamespacePrefix prefix, string name, string value)
+        {
+            Add(string.Format(" which have attribute {0} whose value ends with '{1}'", name, value));
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this attribute selector.
+        /// </summary>
+        public void AttributeSubstring(NamespacePrefix prefix, string name, string value)
+        {
+            Add(string.Format(" which have attribute {0} whose value contains '{1}'", name, value));
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this pseudo-class selector.
+        /// </summary>
+        public void FirstChild()
+        {
+            Add(" which are the first child of their parent");
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this pseudo-class selector.
+        /// </summary>
+        public void LastChild()
+        {
+            Add(" which are the last child of their parent");
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this pseudo-class selector.
+        /// </summary>
+        public void NthChild(int a, int b)
+        {
+            Add(string.Format(" where the element has {0}n+{1}-1 sibling before it", a, b));
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this pseudo-class selector.
+        /// </summary>
+        public void OnlyChild()
+        {
+            Add(" where the element is the only child");
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this pseudo-class selector.
+        /// </summary>
+        public void Empty()
+        {
+            Add(" where the element is empty");
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this combinator.
+        /// </summary>
+        public void Child()
+        {
+            Add(", then take their immediate children which are");
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this combinator.
+        /// </summary>
+        public void Descendant()
+        {
+            if (_chainCount > 0)
+            {
+                Add(". With those, take only their descendants which are");
+            }
+            else
+            {
+                Add(", then take their descendants which are");
+                _chainCount++;
+            }
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this combinator.
+        /// </summary>
+        public void Adjacent()
+        {
+            Add(", then take their immediate siblings which are");
+        }
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#combinators">combinator</a>,
+        /// which separates two sequences of simple selectors. The elements represented
+        /// by the two sequences share the same parent in the document tree and the
+        /// element represented by the first sequence precedes (not necessarily
+        /// immediately) the element represented by the second one.
+        /// </summary>
+        public void GeneralSibling()
+        {
+            Add(", then take their siblings which are");
+        }
+
+        /// <summary>
+        /// Generates human-readable text of this combinator.
+        /// </summary>
+        public void NthLastChild(int a, int b)
+        {
+            Add(string.Format(" where the element has {0}n+{1}-1 sibling after it", a, b));
+        }
+    }
+}
\ No newline at end of file

Source/External/Fizzler/IElementOps.cs

+#region Copyright and License
+// 
+// Fizzler - CSS Selector Engine for Microsoft .NET Framework
+// Copyright (c) 2009 Atif Aziz, Colin Ramsay. All rights reserved.
+// 
+// This library is free software; you can redistribute it and/or modify it under 
+// the terms of the GNU Lesser General Public License as published by the Free 
+// Software Foundation; either version 3 of the License, or (at your option) 
+// any later version.
+// 
+// This library is distributed in the hope that it will be useful, but WITHOUT 
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 
+// details.
+// 
+// You should have received a copy of the GNU Lesser General Public License 
+// along with this library; if not, write to the Free Software Foundation, Inc., 
+// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
+// 
+#endregion
+
+namespace Fizzler
+{
+    /// <summary>
+    /// Represents a selectors implementation for an arbitrary document/node system.
+    /// </summary>
+    public interface IElementOps<TElement>
+    {
+        //
+        // Selectors
+        //
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#type-selectors">type selector</a>,
+        /// which represents an instance of the element type in the document tree. 
+        /// </summary>
+        Selector<TElement> Type(NamespacePrefix prefix, string name);
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#universal-selector">universal selector</a>,
+        /// any single element in the document tree in any namespace 
+        /// (including those without a namespace) if no default namespace 
+        /// has been specified for selectors. 
+        /// </summary>
+        Selector<TElement> Universal(NamespacePrefix prefix);
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#Id-selectors">ID selector</a>,
+        /// which represents an element instance that has an identifier that 
+        /// matches the identifier in the ID selector.
+        /// </summary>
+        Selector<TElement> Id(string id);
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#class-html">class selector</a>,
+        /// which is an alternative <see cref="AttributeIncludes"/> when 
+        /// representing the <c>class</c> attribute. 
+        /// </summary>
+        Selector<TElement> Class(string clazz);
+
+        //
+        // Attribute selectors
+        //
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the given attribute <paramref name="name"/>
+        /// whatever the values of the attribute.
+        /// </summary>
+        Selector<TElement> AttributeExists(NamespacePrefix prefix, string name);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the given attribute <paramref name="name"/>
+        /// and whose value is exactly <paramref name="value"/>.
+        /// </summary>
+        Selector<TElement> AttributeExact(NamespacePrefix prefix, string name, string value);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the given attribute <paramref name="name"/>
+        /// and whose value is a whitespace-separated list of words, one of 
+        /// which is exactly <paramref name="value"/>.
+        /// </summary>
+        Selector<TElement> AttributeIncludes(NamespacePrefix prefix, string name, string value);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the given attribute <paramref name="name"/>,
+        /// its value either being exactly <paramref name="value"/> or beginning 
+        /// with <paramref name="value"/> immediately followed by "-" (U+002D).
+        /// </summary>
+        Selector<TElement> AttributeDashMatch(NamespacePrefix prefix, string name, string value);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the attribute <paramref name="name"/> 
+        /// whose value begins with the prefix <paramref name="value"/>.
+        /// </summary>
+        Selector<TElement> AttributePrefixMatch(NamespacePrefix prefix, string name, string value);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the attribute <paramref name="name"/> 
+        /// whose value ends with the suffix <paramref name="value"/>.
+        /// </summary>
+        Selector<TElement> AttributeSuffixMatch(NamespacePrefix prefix, string name, string value);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the attribute <paramref name="name"/> 
+        /// whose value contains at least one instance of the substring <paramref name="value"/>.
+        /// </summary>
+        Selector<TElement> AttributeSubstring(NamespacePrefix prefix, string name, string value);
+
+        //
+        // Pseudo-class selectors
+        //
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that is the first child of some other element.
+        /// </summary>
+        Selector<TElement> FirstChild();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that is the last child of some other element.
+        /// </summary>
+        Selector<TElement> LastChild();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that is the N-th child of some other element.
+        /// </summary>
+        Selector<TElement> NthChild(int a, int b);
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that has a parent element and whose parent 
+        /// element has no other element children.
+        /// </summary>
+        Selector<TElement> OnlyChild();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that has no children at all.
+        /// </summary>
+        Selector<TElement> Empty();
+
+        //
+        // Combinators
+        //
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#combinators">combinator</a>,
+        /// which represents a childhood relationship between two elements.
+        /// </summary>
+        Selector<TElement> Child();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#combinators">combinator</a>,
+        /// which represents a relationship between two elements where one element is an 
+        /// arbitrary descendant of some ancestor element.
+        /// </summary>
+        Selector<TElement> Descendant();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#combinators">combinator</a>,
+        /// which represents elements that share the same parent in the document tree and 
+        /// where the first element immediately precedes the second element.
+        /// </summary>
+        Selector<TElement> Adjacent();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#combinators">combinator</a>,
+        /// which separates two sequences of simple selectors. The elements represented
+        /// by the two sequences share the same parent in the document tree and the
+        /// element represented by the first sequence precedes (not necessarily
+        /// immediately) the element represented by the second one.
+        /// </summary>
+        Selector<TElement> GeneralSibling();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that is the N-th child from bottom up of some other element.
+        /// </summary>
+        Selector<TElement> NthLastChild(int a, int b);
+    }
+}
\ No newline at end of file

Source/External/Fizzler/ISelectorGenerator.cs

+#region Copyright and License
+// 
+// Fizzler - CSS Selector Engine for Microsoft .NET Framework
+// Copyright (c) 2009 Atif Aziz, Colin Ramsay. All rights reserved.
+// 
+// This library is free software; you can redistribute it and/or modify it under 
+// the terms of the GNU Lesser General Public License as published by the Free 
+// Software Foundation; either version 3 of the License, or (at your option) 
+// any later version.
+// 
+// This library is distributed in the hope that it will be useful, but WITHOUT 
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 
+// details.
+// 
+// You should have received a copy of the GNU Lesser General Public License 
+// along with this library; if not, write to the Free Software Foundation, Inc., 
+// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
+// 
+#endregion
+
+namespace Fizzler
+{
+    /// <summary>
+    /// Represent an implementation that is responsible for generating
+    /// an implementation for a selector.
+    /// </summary>
+    public interface ISelectorGenerator
+    {
+        /// <summary>
+        /// Delimits the initialization of a generation.
+        /// </summary>
+        void OnInit();
+
+        /// <summary>
+        /// Delimits the closing/conclusion of a generation.
+        /// </summary>
+        void OnClose();
+
+        /// <summary>
+        /// Delimits a selector generation in a group of selectors.
+        /// </summary>
+        void OnSelector();
+
+        //
+        // Selectors
+        //
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#type-selectors">type selector</a>,
+        /// which represents an instance of the element type in the document tree. 
+        /// </summary>
+        void Type(NamespacePrefix prefix, string name);
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#universal-selector">universal selector</a>,
+        /// any single element in the document tree in any namespace 
+        /// (including those without a namespace) if no default namespace 
+        /// has been specified for selectors. 
+        /// </summary>
+        void Universal(NamespacePrefix prefix);
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#Id-selectors">ID selector</a>,
+        /// which represents an element instance that has an identifier that 
+        /// matches the identifier in the ID selector.
+        /// </summary>
+        void Id(string id);
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#class-html">class selector</a>,
+        /// which is an alternative <see cref="AttributeIncludes"/> when 
+        /// representing the <c>class</c> attribute. 
+        /// </summary>
+        void Class(string clazz);
+
+        //
+        // Attribute selectors
+        //
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the given attribute <paramref name="name"/>
+        /// whatever the values of the attribute.
+        /// </summary>
+        void AttributeExists(NamespacePrefix prefix, string name);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the given attribute <paramref name="name"/>
+        /// and whose value is exactly <paramref name="value"/>.
+        /// </summary>
+        void AttributeExact(NamespacePrefix prefix, string name, string value);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the given attribute <paramref name="name"/>
+        /// and whose value is a whitespace-separated list of words, one of 
+        /// which is exactly <paramref name="value"/>.
+        /// </summary>
+        void AttributeIncludes(NamespacePrefix prefix, string name, string value);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the given attribute <paramref name="name"/>,
+        /// its value either being exactly <paramref name="value"/> or beginning 
+        /// with <paramref name="value"/> immediately followed by "-" (U+002D).
+        /// </summary>
+        void AttributeDashMatch(NamespacePrefix prefix, string name, string value);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the attribute <paramref name="name"/> 
+        /// whose value begins with the prefix <paramref name="value"/>.
+        /// </summary>
+        void AttributePrefixMatch(NamespacePrefix prefix, string name, string value);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the attribute <paramref name="name"/> 
+        /// whose value ends with the suffix <paramref name="value"/>.
+        /// </summary>
+        void AttributeSuffixMatch(NamespacePrefix prefix, string name, string value);
+
+        /// <summary>
+        /// Generates an <a href="http://www.w3.org/TR/css3-selectors/#attribute-selectors">attribute selector</a>
+        /// that represents an element with the attribute <paramref name="name"/> 
+        /// whose value contains at least one instance of the substring <paramref name="value"/>.
+        /// </summary>
+        void AttributeSubstring(NamespacePrefix prefix, string name, string value);
+
+        //
+        // Pseudo-class selectors
+        //
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that is the first child of some other element.
+        /// </summary>
+        void FirstChild();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that is the last child of some other element.
+        /// </summary>
+        void LastChild();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that is the N-th child of some other element.
+        /// </summary>
+        void NthChild(int a, int b);
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that has a parent element and whose parent 
+        /// element has no other element children.
+        /// </summary>
+        void OnlyChild();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that has no children at all.
+        /// </summary>
+        void Empty();
+
+        //
+        // Combinators
+        //
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#combinators">combinator</a>,
+        /// which represents a childhood relationship between two elements.
+        /// </summary>
+        void Child();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#combinators">combinator</a>,
+        /// which represents a relationship between two elements where one element is an 
+        /// arbitrary descendant of some ancestor element.
+        /// </summary>
+        void Descendant();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#combinators">combinator</a>,
+        /// which represents elements that share the same parent in the document tree and 
+        /// where the first element immediately precedes the second element.
+        /// </summary>
+        void Adjacent();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#combinators">combinator</a>,
+        /// which separates two sequences of simple selectors. The elements represented
+        /// by the two sequences share the same parent in the document tree and the
+        /// element represented by the first sequence precedes (not necessarily
+        /// immediately) the element represented by the second one.
+        /// </summary>
+        void GeneralSibling();
+
+        /// <summary>
+        /// Generates a <a href="http://www.w3.org/TR/css3-selectors/#pseudo-classes">pseudo-class selector</a>,
+        /// which represents an element that is the N-th child from bottom up of some other element.
+        /// </summary>
+        void NthLastChild(int a, int b);
+    }
+}
\ No newline at end of file

Source/External/Fizzler/NamespacePrefix.cs

+#region Copyright and License
+// 
+// Fizzler - CSS Selector Engine for Microsoft .NET Framework
+// Copyright (c) 2009 Atif Aziz, Colin Ramsay. All rights reserved.
+// 
+// This library is free software; you can redistribute it and/or modify it under 
+// the terms of the GNU Lesser General Public License as published by the Free 
+// Software Foundation; either version 3 of the License, or (at your option) 
+// any later version.
+// 
+// This library is distributed in the hope that it will be useful, but WITHOUT 
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 
+// details.
+// 
+// You should have received a copy of the GNU Lesser General Public License 
+// along with this library; if not, write to the Free Software Foundation, Inc., 
+// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
+// 
+#endregion
+
+namespace Fizzler
+{
+    using System;
+
+    /// <summary>
+    /// Represent a type or attribute name.
+    /// </summary>
+    [Serializable]
+    public struct NamespacePrefix
+    {
+        /// <summary>
+        /// Represents a name from either the default or any namespace 
+        /// in a target document, depending on whether a default namespace is
+        /// in effect or not.
+        /// </summary>
+        public static readonly NamespacePrefix None = new NamespacePrefix(null);
+
+        /// <summary>
+        /// Represents an empty namespace.
+        /// </summary>
+        public static readonly NamespacePrefix Empty = new NamespacePrefix(string.Empty);
+
+        /// <summary>
+        /// Represents any namespace.
+        /// </summary>
+        public static readonly NamespacePrefix Any = new NamespacePrefix("*");
+
+        /// <summary>
+        /// Initializes an instance with a namespace prefix specification.
+        /// </summary>
+        public NamespacePrefix(string text) : this()
+        {
+            Text = text;
+        }
+
+        /// <summary>
+        /// Gets the raw text value of this instance.
+        /// </summary>
+        public string Text { get; private set; }
+
+        /// <summary>
+        /// Indicates whether this instance represents a name
+        /// from either the default or any namespace in a target
+        /// document, depending on whether a default namespace is
+        /// in effect or not.
+        /// </summary>
+        public bool IsNone { get { return Text == null; } }
+
+        /// <summary>
+        /// Indicates whether this instance represents a name
+        /// from any namespace (including one without one)
+        /// in a target document.
+        /// </summary>
+        public bool IsAny
+        {
+            get { return !IsNone && Text.Length == 1 && Text[0] == '*'; }
+        }
+
+        /// <summary>
+        /// Indicates whether this instance represents a name
+        /// without a namespace in a target document.
+        /// </summary>
+        public bool IsEmpty { get { return !IsNone && Text.Length == 0; } }
+
+        /// <summary>
+        /// Indicates whether this instance represents a name from a 
+        /// specific namespace or not.
+        /// </summary>
+        public bool IsSpecific { get {return !IsNone && !IsAny; } }
+
+        /// <summary>
+        /// Indicates whether this instance and a specified object are equal.
+        /// </summary>
+        public override bool Equals(object obj)
+        {
+            return obj is NamespacePrefix && Equals((NamespacePrefix) obj);
+        }
+
+        /// <summary>
+        /// Indicates whether this instance and another are equal.
+        /// </summary>
+        public bool Equals(NamespacePrefix other)
+        {
+            return Text == other.Text;
+        }
+
+        /// <summary>
+        /// Returns the hash code for this instance.
+        /// </summary>
+        public override int GetHashCode()
+        {
+            return IsNone ? 0 : Text.GetHashCode();
+        }
+
+        /// <summary>
+        /// Returns a string representation of this instance.
+        /// </summary>
+        public override string ToString()
+        {
+            return IsNone ? "(none)" : Text;
+        }
+
+        /// <summary>
+        /// Formats this namespace together with a name.
+        /// </summary>
+        public string Format(string name)
+        {
+            if (name == null) throw new ArgumentNullException("name");
+            if (name.Length == 0) throw new ArgumentException(null, "name");
+
+            return Text + (IsNone ? null : "|") + name;
+        }
+    }
+}