diff --git a/CommentMacro.g4 b/CommentMacro.g4
index 50b4fe8..33aacfa 100644
--- a/CommentMacro.g4
+++ b/CommentMacro.g4
@@ -32,7 +32,8 @@ grammar CommentMacro;
  ** Parser Rules
  **/
 
-prog        : statement+ EOF ;
+prog        : statement* EOF;
+
 
 statement   : macro (':' macro)* NEWLINE?
             | NEWLINE
diff --git a/CommentMacroParser.py b/CommentMacroParser.py
index ba3bb75..a3000a8 100644
--- a/CommentMacroParser.py
+++ b/CommentMacroParser.py
@@ -8,125 +8,126 @@ import sys
 def serializedATN():
     with StringIO() as buf:
         buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3-")
-        buf.write("\u00fb\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
-        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\3\2\6\2\26\n\2\r\2\16\2\27\3")
-        buf.write("\2\3\2\3\3\3\3\3\3\7\3\37\n\3\f\3\16\3\"\13\3\3\3\5\3")
-        buf.write("%\n\3\3\3\5\3(\n\3\3\4\3\4\3\4\5\4-\n\4\3\4\5\4\60\n\4")
-        buf.write("\3\4\3\4\3\4\5\4\65\n\4\3\4\3\4\3\4\5\4:\n\4\3\4\3\4\3")
-        buf.write("\4\5\4?\n\4\3\4\5\4B\n\4\3\4\3\4\3\4\5\4G\n\4\3\4\5\4")
-        buf.write("J\n\4\3\4\3\4\3\4\5\4O\n\4\3\4\5\4R\n\4\3\4\3\4\5\4V\n")
-        buf.write("\4\3\4\3\4\5\4Z\n\4\3\4\3\4\3\4\5\4_\n\4\3\4\3\4\3\4\5")
-        buf.write("\4d\n\4\3\4\5\4g\n\4\3\4\3\4\3\4\5\4l\n\4\3\4\5\4o\n\4")
-        buf.write("\3\4\3\4\3\4\5\4t\n\4\3\4\3\4\3\4\5\4y\n\4\3\4\3\4\3\4")
-        buf.write("\3\4\3\4\5\4\u0080\n\4\3\4\3\4\3\4\5\4\u0085\n\4\3\4\3")
-        buf.write("\4\3\4\5\4\u008a\n\4\3\4\3\4\3\4\5\4\u008f\n\4\3\4\3\4")
-        buf.write("\3\4\5\4\u0094\n\4\3\4\3\4\3\4\5\4\u0099\n\4\3\4\3\4\3")
-        buf.write("\4\5\4\u009e\n\4\3\4\3\4\3\4\5\4\u00a3\n\4\3\4\3\4\3\4")
-        buf.write("\5\4\u00a8\n\4\3\4\3\4\3\4\5\4\u00ad\n\4\3\4\3\4\3\4\5")
-        buf.write("\4\u00b2\n\4\3\4\3\4\3\4\5\4\u00b7\n\4\3\4\3\4\3\4\5\4")
-        buf.write("\u00bc\n\4\3\4\3\4\3\4\5\4\u00c1\n\4\3\4\3\4\3\4\5\4\u00c6")
-        buf.write("\n\4\3\4\3\4\3\4\5\4\u00cb\n\4\3\4\3\4\3\4\3\4\3\4\5\4")
-        buf.write("\u00d2\n\4\3\4\3\4\3\4\5\4\u00d7\n\4\3\4\3\4\3\4\5\4\u00dc")
-        buf.write("\n\4\3\4\3\4\5\4\u00e0\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7")
-        buf.write("\3\7\3\b\3\b\5\b\u00ec\n\b\3\b\3\b\7\b\u00f0\n\b\f\b\16")
-        buf.write("\b\u00f3\13\b\3\t\3\t\3\t\3\t\3\n\3\n\3\n\2\2\13\2\4\6")
-        buf.write("\b\n\f\16\20\22\2\3\3\2(*\2\u013c\2\25\3\2\2\2\4\'\3\2")
-        buf.write("\2\2\6\u00df\3\2\2\2\b\u00e1\3\2\2\2\n\u00e4\3\2\2\2\f")
-        buf.write("\u00e7\3\2\2\2\16\u00eb\3\2\2\2\20\u00f4\3\2\2\2\22\u00f8")
-        buf.write("\3\2\2\2\24\26\5\4\3\2\25\24\3\2\2\2\26\27\3\2\2\2\27")
-        buf.write("\25\3\2\2\2\27\30\3\2\2\2\30\31\3\2\2\2\31\32\7\2\2\3")
-        buf.write("\32\3\3\2\2\2\33 \5\6\4\2\34\35\7\3\2\2\35\37\5\6\4\2")
-        buf.write("\36\34\3\2\2\2\37\"\3\2\2\2 \36\3\2\2\2 !\3\2\2\2!$\3")
-        buf.write("\2\2\2\" \3\2\2\2#%\7+\2\2$#\3\2\2\2$%\3\2\2\2%(\3\2\2")
-        buf.write("\2&(\7+\2\2\'\33\3\2\2\2\'&\3\2\2\2(\5\3\2\2\2),\7\4\2")
-        buf.write("\2*-\5\16\b\2+-\7&\2\2,*\3\2\2\2,+\3\2\2\2-/\3\2\2\2.")
-        buf.write("\60\5\n\6\2/.\3\2\2\2/\60\3\2\2\2\60\u00e0\3\2\2\2\61")
-        buf.write("\64\7\4\2\2\62\65\5\16\b\2\63\65\7&\2\2\64\62\3\2\2\2")
-        buf.write("\64\63\3\2\2\2\65\66\3\2\2\2\66\67\7\5\2\2\679\5\22\n")
-        buf.write("\28:\5\n\6\298\3\2\2\29:\3\2\2\2:\u00e0\3\2\2\2;>\7\6")
-        buf.write("\2\2<?\5\16\b\2=?\7&\2\2><\3\2\2\2>=\3\2\2\2?A\3\2\2\2")
-        buf.write("@B\5\n\6\2A@\3\2\2\2AB\3\2\2\2B\u00e0\3\2\2\2CF\7\7\2")
-        buf.write("\2DG\5\16\b\2EG\7&\2\2FD\3\2\2\2FE\3\2\2\2GI\3\2\2\2H")
-        buf.write("J\5\n\6\2IH\3\2\2\2IJ\3\2\2\2J\u00e0\3\2\2\2KN\7\b\2\2")
-        buf.write("LO\5\16\b\2MO\7&\2\2NL\3\2\2\2NM\3\2\2\2OQ\3\2\2\2PR\5")
-        buf.write("\n\6\2QP\3\2\2\2QR\3\2\2\2R\u00e0\3\2\2\2SU\7\t\2\2TV")
-        buf.write("\5\n\6\2UT\3\2\2\2UV\3\2\2\2V\u00e0\3\2\2\2WY\7\n\2\2")
-        buf.write("XZ\5\n\6\2YX\3\2\2\2YZ\3\2\2\2Z\u00e0\3\2\2\2[^\7\13\2")
-        buf.write("\2\\_\5\16\b\2]_\7&\2\2^\\\3\2\2\2^]\3\2\2\2_`\3\2\2\2")
-        buf.write("`a\7\5\2\2ac\5\22\n\2bd\5\b\5\2cb\3\2\2\2cd\3\2\2\2df")
-        buf.write("\3\2\2\2eg\5\n\6\2fe\3\2\2\2fg\3\2\2\2g\u00e0\3\2\2\2")
-        buf.write("hi\7\f\2\2ik\5\22\n\2jl\5\b\5\2kj\3\2\2\2kl\3\2\2\2ln")
-        buf.write("\3\2\2\2mo\5\n\6\2nm\3\2\2\2no\3\2\2\2o\u00e0\3\2\2\2")
-        buf.write("pq\7\r\2\2qs\5\22\n\2rt\5\n\6\2sr\3\2\2\2st\3\2\2\2t\u00e0")
-        buf.write("\3\2\2\2uv\7\16\2\2vx\5\16\b\2wy\5\n\6\2xw\3\2\2\2xy\3")
-        buf.write("\2\2\2y\u00e0\3\2\2\2z{\7\16\2\2{|\5\16\b\2|}\7\5\2\2")
-        buf.write("}\177\5\22\n\2~\u0080\5\n\6\2\177~\3\2\2\2\177\u0080\3")
-        buf.write("\2\2\2\u0080\u00e0\3\2\2\2\u0081\u0082\7\17\2\2\u0082")
-        buf.write("\u0084\5\16\b\2\u0083\u0085\5\n\6\2\u0084\u0083\3\2\2")
-        buf.write("\2\u0084\u0085\3\2\2\2\u0085\u00e0\3\2\2\2\u0086\u0087")
-        buf.write("\7\20\2\2\u0087\u0089\5\16\b\2\u0088\u008a\5\n\6\2\u0089")
-        buf.write("\u0088\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u00e0\3\2\2\2")
-        buf.write("\u008b\u008c\7\21\2\2\u008c\u008e\5\16\b\2\u008d\u008f")
-        buf.write("\5\n\6\2\u008e\u008d\3\2\2\2\u008e\u008f\3\2\2\2\u008f")
-        buf.write("\u00e0\3\2\2\2\u0090\u0091\7\22\2\2\u0091\u0093\5\16\b")
-        buf.write("\2\u0092\u0094\5\n\6\2\u0093\u0092\3\2\2\2\u0093\u0094")
-        buf.write("\3\2\2\2\u0094\u00e0\3\2\2\2\u0095\u0096\7\23\2\2\u0096")
-        buf.write("\u0098\5\16\b\2\u0097\u0099\5\n\6\2\u0098\u0097\3\2\2")
-        buf.write("\2\u0098\u0099\3\2\2\2\u0099\u00e0\3\2\2\2\u009a\u009b")
-        buf.write("\7\24\2\2\u009b\u009d\5\16\b\2\u009c\u009e\5\n\6\2\u009d")
-        buf.write("\u009c\3\2\2\2\u009d\u009e\3\2\2\2\u009e\u00e0\3\2\2\2")
-        buf.write("\u009f\u00a0\7\25\2\2\u00a0\u00a2\5\16\b\2\u00a1\u00a3")
-        buf.write("\5\n\6\2\u00a2\u00a1\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3")
-        buf.write("\u00e0\3\2\2\2\u00a4\u00a5\7\26\2\2\u00a5\u00a7\5\16\b")
-        buf.write("\2\u00a6\u00a8\5\n\6\2\u00a7\u00a6\3\2\2\2\u00a7\u00a8")
-        buf.write("\3\2\2\2\u00a8\u00e0\3\2\2\2\u00a9\u00aa\7\27\2\2\u00aa")
-        buf.write("\u00ac\5\16\b\2\u00ab\u00ad\5\n\6\2\u00ac\u00ab\3\2\2")
-        buf.write("\2\u00ac\u00ad\3\2\2\2\u00ad\u00e0\3\2\2\2\u00ae\u00af")
-        buf.write("\7\30\2\2\u00af\u00b1\5\16\b\2\u00b0\u00b2\5\n\6\2\u00b1")
-        buf.write("\u00b0\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00e0\3\2\2\2")
-        buf.write("\u00b3\u00b4\7\31\2\2\u00b4\u00b6\5\16\b\2\u00b5\u00b7")
-        buf.write("\5\n\6\2\u00b6\u00b5\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7")
-        buf.write("\u00e0\3\2\2\2\u00b8\u00b9\7\32\2\2\u00b9\u00bb\5\22\n")
-        buf.write("\2\u00ba\u00bc\5\n\6\2\u00bb\u00ba\3\2\2\2\u00bb\u00bc")
-        buf.write("\3\2\2\2\u00bc\u00e0\3\2\2\2\u00bd\u00be\7\32\2\2\u00be")
-        buf.write("\u00c0\7\33\2\2\u00bf\u00c1\5\n\6\2\u00c0\u00bf\3\2\2")
-        buf.write("\2\u00c0\u00c1\3\2\2\2\u00c1\u00e0\3\2\2\2\u00c2\u00c3")
-        buf.write("\7\32\2\2\u00c3\u00c5\7\34\2\2\u00c4\u00c6\5\n\6\2\u00c5")
-        buf.write("\u00c4\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6\u00e0\3\2\2\2")
-        buf.write("\u00c7\u00c8\7\35\2\2\u00c8\u00ca\5\22\n\2\u00c9\u00cb")
-        buf.write("\5\n\6\2\u00ca\u00c9\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb")
-        buf.write("\u00e0\3\2\2\2\u00cc\u00cd\7\36\2\2\u00cd\u00e0\5\n\6")
-        buf.write("\2\u00ce\u00cf\7\37\2\2\u00cf\u00d1\5\16\b\2\u00d0\u00d2")
-        buf.write("\5\n\6\2\u00d1\u00d0\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2")
-        buf.write("\u00e0\3\2\2\2\u00d3\u00d4\7 \2\2\u00d4\u00d6\5\16\b\2")
-        buf.write("\u00d5\u00d7\5\n\6\2\u00d6\u00d5\3\2\2\2\u00d6\u00d7\3")
-        buf.write("\2\2\2\u00d7\u00e0\3\2\2\2\u00d8\u00d9\7!\2\2\u00d9\u00db")
-        buf.write("\5\16\b\2\u00da\u00dc\5\n\6\2\u00db\u00da\3\2\2\2\u00db")
-        buf.write("\u00dc\3\2\2\2\u00dc\u00e0\3\2\2\2\u00dd\u00de\7\"\2\2")
-        buf.write("\u00de\u00e0\5\22\n\2\u00df)\3\2\2\2\u00df\61\3\2\2\2")
-        buf.write("\u00df;\3\2\2\2\u00dfC\3\2\2\2\u00dfK\3\2\2\2\u00dfS\3")
-        buf.write("\2\2\2\u00dfW\3\2\2\2\u00df[\3\2\2\2\u00dfh\3\2\2\2\u00df")
-        buf.write("p\3\2\2\2\u00dfu\3\2\2\2\u00dfz\3\2\2\2\u00df\u0081\3")
-        buf.write("\2\2\2\u00df\u0086\3\2\2\2\u00df\u008b\3\2\2\2\u00df\u0090")
-        buf.write("\3\2\2\2\u00df\u0095\3\2\2\2\u00df\u009a\3\2\2\2\u00df")
-        buf.write("\u009f\3\2\2\2\u00df\u00a4\3\2\2\2\u00df\u00a9\3\2\2\2")
-        buf.write("\u00df\u00ae\3\2\2\2\u00df\u00b3\3\2\2\2\u00df\u00b8\3")
-        buf.write("\2\2\2\u00df\u00bd\3\2\2\2\u00df\u00c2\3\2\2\2\u00df\u00c7")
-        buf.write("\3\2\2\2\u00df\u00cc\3\2\2\2\u00df\u00ce\3\2\2\2\u00df")
-        buf.write("\u00d3\3\2\2\2\u00df\u00d8\3\2\2\2\u00df\u00dd\3\2\2\2")
-        buf.write("\u00e0\7\3\2\2\2\u00e1\u00e2\7\'\2\2\u00e2\u00e3\5\22")
-        buf.write("\n\2\u00e3\t\3\2\2\2\u00e4\u00e5\5\f\7\2\u00e5\u00e6\5")
-        buf.write("\22\n\2\u00e6\13\3\2\2\2\u00e7\u00e8\t\2\2\2\u00e8\r\3")
-        buf.write("\2\2\2\u00e9\u00ec\5\22\n\2\u00ea\u00ec\5\20\t\2\u00eb")
-        buf.write("\u00e9\3\2\2\2\u00eb\u00ea\3\2\2\2\u00ec\u00f1\3\2\2\2")
-        buf.write("\u00ed\u00ee\7#\2\2\u00ee\u00f0\5\16\b\2\u00ef\u00ed\3")
-        buf.write("\2\2\2\u00f0\u00f3\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f1\u00f2")
-        buf.write("\3\2\2\2\u00f2\17\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f4\u00f5")
-        buf.write("\5\22\n\2\u00f5\u00f6\7%\2\2\u00f6\u00f7\5\22\n\2\u00f7")
-        buf.write("\21\3\2\2\2\u00f8\u00f9\7$\2\2\u00f9\23\3\2\2\2/\27 $")
-        buf.write("\',/\649>AFINQUY^cfknsx\177\u0084\u0089\u008e\u0093\u0098")
-        buf.write("\u009d\u00a2\u00a7\u00ac\u00b1\u00b6\u00bb\u00c0\u00c5")
-        buf.write("\u00ca\u00d1\u00d6\u00db\u00df\u00eb\u00f1")
+        buf.write("\u00fc\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\3\2\7\2\26\n\2\f\2\16\2\31\13")
+        buf.write("\2\3\2\3\2\3\3\3\3\3\3\7\3 \n\3\f\3\16\3#\13\3\3\3\5\3")
+        buf.write("&\n\3\3\3\5\3)\n\3\3\4\3\4\3\4\5\4.\n\4\3\4\5\4\61\n\4")
+        buf.write("\3\4\3\4\3\4\5\4\66\n\4\3\4\3\4\3\4\5\4;\n\4\3\4\3\4\3")
+        buf.write("\4\5\4@\n\4\3\4\5\4C\n\4\3\4\3\4\3\4\5\4H\n\4\3\4\5\4")
+        buf.write("K\n\4\3\4\3\4\3\4\5\4P\n\4\3\4\5\4S\n\4\3\4\3\4\5\4W\n")
+        buf.write("\4\3\4\3\4\5\4[\n\4\3\4\3\4\3\4\5\4`\n\4\3\4\3\4\3\4\5")
+        buf.write("\4e\n\4\3\4\5\4h\n\4\3\4\3\4\3\4\5\4m\n\4\3\4\5\4p\n\4")
+        buf.write("\3\4\3\4\3\4\5\4u\n\4\3\4\3\4\3\4\5\4z\n\4\3\4\3\4\3\4")
+        buf.write("\3\4\3\4\5\4\u0081\n\4\3\4\3\4\3\4\5\4\u0086\n\4\3\4\3")
+        buf.write("\4\3\4\5\4\u008b\n\4\3\4\3\4\3\4\5\4\u0090\n\4\3\4\3\4")
+        buf.write("\3\4\5\4\u0095\n\4\3\4\3\4\3\4\5\4\u009a\n\4\3\4\3\4\3")
+        buf.write("\4\5\4\u009f\n\4\3\4\3\4\3\4\5\4\u00a4\n\4\3\4\3\4\3\4")
+        buf.write("\5\4\u00a9\n\4\3\4\3\4\3\4\5\4\u00ae\n\4\3\4\3\4\3\4\5")
+        buf.write("\4\u00b3\n\4\3\4\3\4\3\4\5\4\u00b8\n\4\3\4\3\4\3\4\5\4")
+        buf.write("\u00bd\n\4\3\4\3\4\3\4\5\4\u00c2\n\4\3\4\3\4\3\4\5\4\u00c7")
+        buf.write("\n\4\3\4\3\4\3\4\5\4\u00cc\n\4\3\4\3\4\3\4\3\4\3\4\5\4")
+        buf.write("\u00d3\n\4\3\4\3\4\3\4\5\4\u00d8\n\4\3\4\3\4\3\4\5\4\u00dd")
+        buf.write("\n\4\3\4\3\4\5\4\u00e1\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7")
+        buf.write("\3\7\3\b\3\b\5\b\u00ed\n\b\3\b\3\b\7\b\u00f1\n\b\f\b\16")
+        buf.write("\b\u00f4\13\b\3\t\3\t\3\t\3\t\3\n\3\n\3\n\2\2\13\2\4\6")
+        buf.write("\b\n\f\16\20\22\2\3\3\2(*\2\u013d\2\27\3\2\2\2\4(\3\2")
+        buf.write("\2\2\6\u00e0\3\2\2\2\b\u00e2\3\2\2\2\n\u00e5\3\2\2\2\f")
+        buf.write("\u00e8\3\2\2\2\16\u00ec\3\2\2\2\20\u00f5\3\2\2\2\22\u00f9")
+        buf.write("\3\2\2\2\24\26\5\4\3\2\25\24\3\2\2\2\26\31\3\2\2\2\27")
+        buf.write("\25\3\2\2\2\27\30\3\2\2\2\30\32\3\2\2\2\31\27\3\2\2\2")
+        buf.write("\32\33\7\2\2\3\33\3\3\2\2\2\34!\5\6\4\2\35\36\7\3\2\2")
+        buf.write("\36 \5\6\4\2\37\35\3\2\2\2 #\3\2\2\2!\37\3\2\2\2!\"\3")
+        buf.write("\2\2\2\"%\3\2\2\2#!\3\2\2\2$&\7+\2\2%$\3\2\2\2%&\3\2\2")
+        buf.write("\2&)\3\2\2\2\')\7+\2\2(\34\3\2\2\2(\'\3\2\2\2)\5\3\2\2")
+        buf.write("\2*-\7\4\2\2+.\5\16\b\2,.\7&\2\2-+\3\2\2\2-,\3\2\2\2.")
+        buf.write("\60\3\2\2\2/\61\5\n\6\2\60/\3\2\2\2\60\61\3\2\2\2\61\u00e1")
+        buf.write("\3\2\2\2\62\65\7\4\2\2\63\66\5\16\b\2\64\66\7&\2\2\65")
+        buf.write("\63\3\2\2\2\65\64\3\2\2\2\66\67\3\2\2\2\678\7\5\2\28:")
+        buf.write("\5\22\n\29;\5\n\6\2:9\3\2\2\2:;\3\2\2\2;\u00e1\3\2\2\2")
+        buf.write("<?\7\6\2\2=@\5\16\b\2>@\7&\2\2?=\3\2\2\2?>\3\2\2\2@B\3")
+        buf.write("\2\2\2AC\5\n\6\2BA\3\2\2\2BC\3\2\2\2C\u00e1\3\2\2\2DG")
+        buf.write("\7\7\2\2EH\5\16\b\2FH\7&\2\2GE\3\2\2\2GF\3\2\2\2HJ\3\2")
+        buf.write("\2\2IK\5\n\6\2JI\3\2\2\2JK\3\2\2\2K\u00e1\3\2\2\2LO\7")
+        buf.write("\b\2\2MP\5\16\b\2NP\7&\2\2OM\3\2\2\2ON\3\2\2\2PR\3\2\2")
+        buf.write("\2QS\5\n\6\2RQ\3\2\2\2RS\3\2\2\2S\u00e1\3\2\2\2TV\7\t")
+        buf.write("\2\2UW\5\n\6\2VU\3\2\2\2VW\3\2\2\2W\u00e1\3\2\2\2XZ\7")
+        buf.write("\n\2\2Y[\5\n\6\2ZY\3\2\2\2Z[\3\2\2\2[\u00e1\3\2\2\2\\")
+        buf.write("_\7\13\2\2]`\5\16\b\2^`\7&\2\2_]\3\2\2\2_^\3\2\2\2`a\3")
+        buf.write("\2\2\2ab\7\5\2\2bd\5\22\n\2ce\5\b\5\2dc\3\2\2\2de\3\2")
+        buf.write("\2\2eg\3\2\2\2fh\5\n\6\2gf\3\2\2\2gh\3\2\2\2h\u00e1\3")
+        buf.write("\2\2\2ij\7\f\2\2jl\5\22\n\2km\5\b\5\2lk\3\2\2\2lm\3\2")
+        buf.write("\2\2mo\3\2\2\2np\5\n\6\2on\3\2\2\2op\3\2\2\2p\u00e1\3")
+        buf.write("\2\2\2qr\7\r\2\2rt\5\22\n\2su\5\n\6\2ts\3\2\2\2tu\3\2")
+        buf.write("\2\2u\u00e1\3\2\2\2vw\7\16\2\2wy\5\16\b\2xz\5\n\6\2yx")
+        buf.write("\3\2\2\2yz\3\2\2\2z\u00e1\3\2\2\2{|\7\16\2\2|}\5\16\b")
+        buf.write("\2}~\7\5\2\2~\u0080\5\22\n\2\177\u0081\5\n\6\2\u0080\177")
+        buf.write("\3\2\2\2\u0080\u0081\3\2\2\2\u0081\u00e1\3\2\2\2\u0082")
+        buf.write("\u0083\7\17\2\2\u0083\u0085\5\16\b\2\u0084\u0086\5\n\6")
+        buf.write("\2\u0085\u0084\3\2\2\2\u0085\u0086\3\2\2\2\u0086\u00e1")
+        buf.write("\3\2\2\2\u0087\u0088\7\20\2\2\u0088\u008a\5\16\b\2\u0089")
+        buf.write("\u008b\5\n\6\2\u008a\u0089\3\2\2\2\u008a\u008b\3\2\2\2")
+        buf.write("\u008b\u00e1\3\2\2\2\u008c\u008d\7\21\2\2\u008d\u008f")
+        buf.write("\5\16\b\2\u008e\u0090\5\n\6\2\u008f\u008e\3\2\2\2\u008f")
+        buf.write("\u0090\3\2\2\2\u0090\u00e1\3\2\2\2\u0091\u0092\7\22\2")
+        buf.write("\2\u0092\u0094\5\16\b\2\u0093\u0095\5\n\6\2\u0094\u0093")
+        buf.write("\3\2\2\2\u0094\u0095\3\2\2\2\u0095\u00e1\3\2\2\2\u0096")
+        buf.write("\u0097\7\23\2\2\u0097\u0099\5\16\b\2\u0098\u009a\5\n\6")
+        buf.write("\2\u0099\u0098\3\2\2\2\u0099\u009a\3\2\2\2\u009a\u00e1")
+        buf.write("\3\2\2\2\u009b\u009c\7\24\2\2\u009c\u009e\5\16\b\2\u009d")
+        buf.write("\u009f\5\n\6\2\u009e\u009d\3\2\2\2\u009e\u009f\3\2\2\2")
+        buf.write("\u009f\u00e1\3\2\2\2\u00a0\u00a1\7\25\2\2\u00a1\u00a3")
+        buf.write("\5\16\b\2\u00a2\u00a4\5\n\6\2\u00a3\u00a2\3\2\2\2\u00a3")
+        buf.write("\u00a4\3\2\2\2\u00a4\u00e1\3\2\2\2\u00a5\u00a6\7\26\2")
+        buf.write("\2\u00a6\u00a8\5\16\b\2\u00a7\u00a9\5\n\6\2\u00a8\u00a7")
+        buf.write("\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00e1\3\2\2\2\u00aa")
+        buf.write("\u00ab\7\27\2\2\u00ab\u00ad\5\16\b\2\u00ac\u00ae\5\n\6")
+        buf.write("\2\u00ad\u00ac\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae\u00e1")
+        buf.write("\3\2\2\2\u00af\u00b0\7\30\2\2\u00b0\u00b2\5\16\b\2\u00b1")
+        buf.write("\u00b3\5\n\6\2\u00b2\u00b1\3\2\2\2\u00b2\u00b3\3\2\2\2")
+        buf.write("\u00b3\u00e1\3\2\2\2\u00b4\u00b5\7\31\2\2\u00b5\u00b7")
+        buf.write("\5\16\b\2\u00b6\u00b8\5\n\6\2\u00b7\u00b6\3\2\2\2\u00b7")
+        buf.write("\u00b8\3\2\2\2\u00b8\u00e1\3\2\2\2\u00b9\u00ba\7\32\2")
+        buf.write("\2\u00ba\u00bc\5\22\n\2\u00bb\u00bd\5\n\6\2\u00bc\u00bb")
+        buf.write("\3\2\2\2\u00bc\u00bd\3\2\2\2\u00bd\u00e1\3\2\2\2\u00be")
+        buf.write("\u00bf\7\32\2\2\u00bf\u00c1\7\33\2\2\u00c0\u00c2\5\n\6")
+        buf.write("\2\u00c1\u00c0\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2\u00e1")
+        buf.write("\3\2\2\2\u00c3\u00c4\7\32\2\2\u00c4\u00c6\7\34\2\2\u00c5")
+        buf.write("\u00c7\5\n\6\2\u00c6\u00c5\3\2\2\2\u00c6\u00c7\3\2\2\2")
+        buf.write("\u00c7\u00e1\3\2\2\2\u00c8\u00c9\7\35\2\2\u00c9\u00cb")
+        buf.write("\5\22\n\2\u00ca\u00cc\5\n\6\2\u00cb\u00ca\3\2\2\2\u00cb")
+        buf.write("\u00cc\3\2\2\2\u00cc\u00e1\3\2\2\2\u00cd\u00ce\7\36\2")
+        buf.write("\2\u00ce\u00e1\5\n\6\2\u00cf\u00d0\7\37\2\2\u00d0\u00d2")
+        buf.write("\5\16\b\2\u00d1\u00d3\5\n\6\2\u00d2\u00d1\3\2\2\2\u00d2")
+        buf.write("\u00d3\3\2\2\2\u00d3\u00e1\3\2\2\2\u00d4\u00d5\7 \2\2")
+        buf.write("\u00d5\u00d7\5\16\b\2\u00d6\u00d8\5\n\6\2\u00d7\u00d6")
+        buf.write("\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8\u00e1\3\2\2\2\u00d9")
+        buf.write("\u00da\7!\2\2\u00da\u00dc\5\16\b\2\u00db\u00dd\5\n\6\2")
+        buf.write("\u00dc\u00db\3\2\2\2\u00dc\u00dd\3\2\2\2\u00dd\u00e1\3")
+        buf.write("\2\2\2\u00de\u00df\7\"\2\2\u00df\u00e1\5\22\n\2\u00e0")
+        buf.write("*\3\2\2\2\u00e0\62\3\2\2\2\u00e0<\3\2\2\2\u00e0D\3\2\2")
+        buf.write("\2\u00e0L\3\2\2\2\u00e0T\3\2\2\2\u00e0X\3\2\2\2\u00e0")
+        buf.write("\\\3\2\2\2\u00e0i\3\2\2\2\u00e0q\3\2\2\2\u00e0v\3\2\2")
+        buf.write("\2\u00e0{\3\2\2\2\u00e0\u0082\3\2\2\2\u00e0\u0087\3\2")
+        buf.write("\2\2\u00e0\u008c\3\2\2\2\u00e0\u0091\3\2\2\2\u00e0\u0096")
+        buf.write("\3\2\2\2\u00e0\u009b\3\2\2\2\u00e0\u00a0\3\2\2\2\u00e0")
+        buf.write("\u00a5\3\2\2\2\u00e0\u00aa\3\2\2\2\u00e0\u00af\3\2\2\2")
+        buf.write("\u00e0\u00b4\3\2\2\2\u00e0\u00b9\3\2\2\2\u00e0\u00be\3")
+        buf.write("\2\2\2\u00e0\u00c3\3\2\2\2\u00e0\u00c8\3\2\2\2\u00e0\u00cd")
+        buf.write("\3\2\2\2\u00e0\u00cf\3\2\2\2\u00e0\u00d4\3\2\2\2\u00e0")
+        buf.write("\u00d9\3\2\2\2\u00e0\u00de\3\2\2\2\u00e1\7\3\2\2\2\u00e2")
+        buf.write("\u00e3\7\'\2\2\u00e3\u00e4\5\22\n\2\u00e4\t\3\2\2\2\u00e5")
+        buf.write("\u00e6\5\f\7\2\u00e6\u00e7\5\22\n\2\u00e7\13\3\2\2\2\u00e8")
+        buf.write("\u00e9\t\2\2\2\u00e9\r\3\2\2\2\u00ea\u00ed\5\22\n\2\u00eb")
+        buf.write("\u00ed\5\20\t\2\u00ec\u00ea\3\2\2\2\u00ec\u00eb\3\2\2")
+        buf.write("\2\u00ed\u00f2\3\2\2\2\u00ee\u00ef\7#\2\2\u00ef\u00f1")
+        buf.write("\5\16\b\2\u00f0\u00ee\3\2\2\2\u00f1\u00f4\3\2\2\2\u00f2")
+        buf.write("\u00f0\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\17\3\2\2\2\u00f4")
+        buf.write("\u00f2\3\2\2\2\u00f5\u00f6\5\22\n\2\u00f6\u00f7\7%\2\2")
+        buf.write("\u00f7\u00f8\5\22\n\2\u00f8\21\3\2\2\2\u00f9\u00fa\7$")
+        buf.write("\2\2\u00fa\23\3\2\2\2/\27!%(-\60\65:?BGJORVZ_dgloty\u0080")
+        buf.write("\u0085\u008a\u008f\u0094\u0099\u009e\u00a3\u00a8\u00ad")
+        buf.write("\u00b2\u00b7\u00bc\u00c1\u00c6\u00cb\u00d2\u00d7\u00dc")
+        buf.write("\u00e0\u00ec\u00f2")
         return buf.getvalue()
 
 
@@ -263,19 +264,17 @@ class CommentMacroParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 19 
+            self.state = 21
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while True:
+            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.T__1) | (1 << CommentMacroParser.T__3) | (1 << CommentMacroParser.T__4) | (1 << CommentMacroParser.T__5) | (1 << CommentMacroParser.T__6) | (1 << CommentMacroParser.T__7) | (1 << CommentMacroParser.T__8) | (1 << CommentMacroParser.T__9) | (1 << CommentMacroParser.T__10) | (1 << CommentMacroParser.T__11) | (1 << CommentMacroParser.T__12) | (1 << CommentMacroParser.T__13) | (1 << CommentMacroParser.T__14) | (1 << CommentMacroParser.T__15) | (1 << CommentMacroParser.T__16) | (1 << CommentMacroParser.T__17) | (1 << CommentMacroParser.T__18) | (1 << CommentMacroParser.T__19) | (1 << CommentMacroParser.T__20) | (1 << CommentMacroParser.T__21) | (1 << CommentMacroParser.T__22) | (1 << CommentMacroParser.T__23) | (1 << CommentMacroParser.T__26) | (1 << CommentMacroParser.T__27) | (1 << CommentMacroParser.T__28) | (1 << CommentMacroParser.T__29) | (1 << CommentMacroParser.T__30) | (1 << CommentMacroParser.T__31) | (1 << CommentMacroParser.NEWLINE))) != 0):
                 self.state = 18
                 self.statement()
-                self.state = 21 
+                self.state = 23
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.T__1) | (1 << CommentMacroParser.T__3) | (1 << CommentMacroParser.T__4) | (1 << CommentMacroParser.T__5) | (1 << CommentMacroParser.T__6) | (1 << CommentMacroParser.T__7) | (1 << CommentMacroParser.T__8) | (1 << CommentMacroParser.T__9) | (1 << CommentMacroParser.T__10) | (1 << CommentMacroParser.T__11) | (1 << CommentMacroParser.T__12) | (1 << CommentMacroParser.T__13) | (1 << CommentMacroParser.T__14) | (1 << CommentMacroParser.T__15) | (1 << CommentMacroParser.T__16) | (1 << CommentMacroParser.T__17) | (1 << CommentMacroParser.T__18) | (1 << CommentMacroParser.T__19) | (1 << CommentMacroParser.T__20) | (1 << CommentMacroParser.T__21) | (1 << CommentMacroParser.T__22) | (1 << CommentMacroParser.T__23) | (1 << CommentMacroParser.T__26) | (1 << CommentMacroParser.T__27) | (1 << CommentMacroParser.T__28) | (1 << CommentMacroParser.T__29) | (1 << CommentMacroParser.T__30) | (1 << CommentMacroParser.T__31) | (1 << CommentMacroParser.NEWLINE))) != 0)):
-                    break
 
-            self.state = 23
+            self.state = 24
             self.match(CommentMacroParser.EOF)
         except RecognitionException as re:
             localctx.exception = re
@@ -321,37 +320,37 @@ class CommentMacroParser ( Parser ):
         self.enterRule(localctx, 2, self.RULE_statement)
         self._la = 0 # Token type
         try:
-            self.state = 37
+            self.state = 38
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [CommentMacroParser.T__1, CommentMacroParser.T__3, CommentMacroParser.T__4, CommentMacroParser.T__5, CommentMacroParser.T__6, CommentMacroParser.T__7, CommentMacroParser.T__8, CommentMacroParser.T__9, CommentMacroParser.T__10, CommentMacroParser.T__11, CommentMacroParser.T__12, CommentMacroParser.T__13, CommentMacroParser.T__14, CommentMacroParser.T__15, CommentMacroParser.T__16, CommentMacroParser.T__17, CommentMacroParser.T__18, CommentMacroParser.T__19, CommentMacroParser.T__20, CommentMacroParser.T__21, CommentMacroParser.T__22, CommentMacroParser.T__23, CommentMacroParser.T__26, CommentMacroParser.T__27, CommentMacroParser.T__28, CommentMacroParser.T__29, CommentMacroParser.T__30, CommentMacroParser.T__31]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 25
+                self.state = 26
                 self.macro()
-                self.state = 30
+                self.state = 31
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==CommentMacroParser.T__0:
-                    self.state = 26
-                    self.match(CommentMacroParser.T__0)
                     self.state = 27
+                    self.match(CommentMacroParser.T__0)
+                    self.state = 28
                     self.macro()
-                    self.state = 32
+                    self.state = 33
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 34
+                self.state = 35
                 self._errHandler.sync(self)
                 la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
                 if la_ == 1:
-                    self.state = 33
+                    self.state = 34
                     self.match(CommentMacroParser.NEWLINE)
 
 
                 pass
             elif token in [CommentMacroParser.NEWLINE]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 36
+                self.state = 37
                 self.match(CommentMacroParser.NEWLINE)
                 pass
             else:
@@ -1089,33 +1088,33 @@ class CommentMacroParser ( Parser ):
         self.enterRule(localctx, 4, self.RULE_macro)
         self._la = 0 # Token type
         try:
-            self.state = 221
+            self.state = 222
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
             if la_ == 1:
                 localctx = CommentMacroParser.MasterGoContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 39
+                self.state = 40
                 self.match(CommentMacroParser.T__1)
-                self.state = 42
+                self.state = 43
                 self._errHandler.sync(self)
                 token = self._input.LA(1)
                 if token in [CommentMacroParser.NUMBER]:
-                    self.state = 40
+                    self.state = 41
                     self.target()
                     pass
                 elif token in [CommentMacroParser.CURRENT]:
-                    self.state = 41
+                    self.state = 42
                     self.match(CommentMacroParser.CURRENT)
                     pass
                 else:
                     raise NoViableAltException(self)
 
-                self.state = 45
+                self.state = 46
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 44
+                    self.state = 45
                     self.device()
 
 
@@ -1124,31 +1123,31 @@ class CommentMacroParser ( Parser ):
             elif la_ == 2:
                 localctx = CommentMacroParser.MasterGotoContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 47
+                self.state = 48
                 self.match(CommentMacroParser.T__1)
-                self.state = 50
+                self.state = 51
                 self._errHandler.sync(self)
                 token = self._input.LA(1)
                 if token in [CommentMacroParser.NUMBER]:
-                    self.state = 48
+                    self.state = 49
                     self.target()
                     pass
                 elif token in [CommentMacroParser.CURRENT]:
-                    self.state = 49
+                    self.state = 50
                     self.match(CommentMacroParser.CURRENT)
                     pass
                 else:
                     raise NoViableAltException(self)
 
-                self.state = 52
-                self.match(CommentMacroParser.T__2)
                 self.state = 53
+                self.match(CommentMacroParser.T__2)
+                self.state = 54
                 self.number()
-                self.state = 55
+                self.state = 56
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 54
+                    self.state = 55
                     self.device()
 
 
@@ -1157,27 +1156,27 @@ class CommentMacroParser ( Parser ):
             elif la_ == 3:
                 localctx = CommentMacroParser.MasterHaltContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 57
+                self.state = 58
                 self.match(CommentMacroParser.T__3)
-                self.state = 60
+                self.state = 61
                 self._errHandler.sync(self)
                 token = self._input.LA(1)
                 if token in [CommentMacroParser.NUMBER]:
-                    self.state = 58
+                    self.state = 59
                     self.target()
                     pass
                 elif token in [CommentMacroParser.CURRENT]:
-                    self.state = 59
+                    self.state = 60
                     self.match(CommentMacroParser.CURRENT)
                     pass
                 else:
                     raise NoViableAltException(self)
 
-                self.state = 63
+                self.state = 64
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 62
+                    self.state = 63
                     self.device()
 
 
@@ -1186,27 +1185,27 @@ class CommentMacroParser ( Parser ):
             elif la_ == 4:
                 localctx = CommentMacroParser.MasterAssertContext(self, localctx)
                 self.enterOuterAlt(localctx, 4)
-                self.state = 65
+                self.state = 66
                 self.match(CommentMacroParser.T__4)
-                self.state = 68
+                self.state = 69
                 self._errHandler.sync(self)
                 token = self._input.LA(1)
                 if token in [CommentMacroParser.NUMBER]:
-                    self.state = 66
+                    self.state = 67
                     self.target()
                     pass
                 elif token in [CommentMacroParser.CURRENT]:
-                    self.state = 67
+                    self.state = 68
                     self.match(CommentMacroParser.CURRENT)
                     pass
                 else:
                     raise NoViableAltException(self)
 
-                self.state = 71
+                self.state = 72
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 70
+                    self.state = 71
                     self.device()
 
 
@@ -1215,27 +1214,27 @@ class CommentMacroParser ( Parser ):
             elif la_ == 5:
                 localctx = CommentMacroParser.MasterReleaseContext(self, localctx)
                 self.enterOuterAlt(localctx, 5)
-                self.state = 73
+                self.state = 74
                 self.match(CommentMacroParser.T__5)
-                self.state = 76
+                self.state = 77
                 self._errHandler.sync(self)
                 token = self._input.LA(1)
                 if token in [CommentMacroParser.NUMBER]:
-                    self.state = 74
+                    self.state = 75
                     self.target()
                     pass
                 elif token in [CommentMacroParser.CURRENT]:
-                    self.state = 75
+                    self.state = 76
                     self.match(CommentMacroParser.CURRENT)
                     pass
                 else:
                     raise NoViableAltException(self)
 
-                self.state = 79
+                self.state = 80
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 78
+                    self.state = 79
                     self.device()
 
 
@@ -1244,13 +1243,13 @@ class CommentMacroParser ( Parser ):
             elif la_ == 6:
                 localctx = CommentMacroParser.ReleaseAllContext(self, localctx)
                 self.enterOuterAlt(localctx, 6)
-                self.state = 81
+                self.state = 82
                 self.match(CommentMacroParser.T__6)
-                self.state = 83
+                self.state = 84
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 82
+                    self.state = 83
                     self.device()
 
 
@@ -1259,13 +1258,13 @@ class CommentMacroParser ( Parser ):
             elif la_ == 7:
                 localctx = CommentMacroParser.ReleaseOthersContext(self, localctx)
                 self.enterOuterAlt(localctx, 7)
-                self.state = 85
+                self.state = 86
                 self.match(CommentMacroParser.T__7)
-                self.state = 87
+                self.state = 88
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 86
+                    self.state = 87
                     self.device()
 
 
@@ -1274,39 +1273,39 @@ class CommentMacroParser ( Parser ):
             elif la_ == 8:
                 localctx = CommentMacroParser.MasterFadeContext(self, localctx)
                 self.enterOuterAlt(localctx, 8)
-                self.state = 89
+                self.state = 90
                 self.match(CommentMacroParser.T__8)
-                self.state = 92
+                self.state = 93
                 self._errHandler.sync(self)
                 token = self._input.LA(1)
                 if token in [CommentMacroParser.NUMBER]:
-                    self.state = 90
+                    self.state = 91
                     self.target()
                     pass
                 elif token in [CommentMacroParser.CURRENT]:
-                    self.state = 91
+                    self.state = 92
                     self.match(CommentMacroParser.CURRENT)
                     pass
                 else:
                     raise NoViableAltException(self)
 
-                self.state = 94
-                self.match(CommentMacroParser.T__2)
                 self.state = 95
+                self.match(CommentMacroParser.T__2)
+                self.state = 96
                 self.number()
-                self.state = 97
+                self.state = 98
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==CommentMacroParser.TIME:
-                    self.state = 96
+                    self.state = 97
                     self.time()
 
 
-                self.state = 100
+                self.state = 101
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 99
+                    self.state = 100
                     self.device()
 
 
@@ -1315,23 +1314,23 @@ class CommentMacroParser ( Parser ):
             elif la_ == 9:
                 localctx = CommentMacroParser.FadeGrandMasterContext(self, localctx)
                 self.enterOuterAlt(localctx, 9)
-                self.state = 102
-                self.match(CommentMacroParser.T__9)
                 self.state = 103
+                self.match(CommentMacroParser.T__9)
+                self.state = 104
                 self.number()
-                self.state = 105
+                self.state = 106
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==CommentMacroParser.TIME:
-                    self.state = 104
+                    self.state = 105
                     self.time()
 
 
-                self.state = 108
+                self.state = 109
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 107
+                    self.state = 108
                     self.device()
 
 
@@ -1340,15 +1339,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 10:
                 localctx = CommentMacroParser.MasterChooseContext(self, localctx)
                 self.enterOuterAlt(localctx, 10)
-                self.state = 110
-                self.match(CommentMacroParser.T__10)
                 self.state = 111
+                self.match(CommentMacroParser.T__10)
+                self.state = 112
                 self.number()
-                self.state = 113
+                self.state = 114
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 112
+                    self.state = 113
                     self.device()
 
 
@@ -1357,15 +1356,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 11:
                 localctx = CommentMacroParser.ListGoContext(self, localctx)
                 self.enterOuterAlt(localctx, 11)
-                self.state = 115
-                self.match(CommentMacroParser.T__11)
                 self.state = 116
+                self.match(CommentMacroParser.T__11)
+                self.state = 117
                 self.target()
-                self.state = 118
+                self.state = 119
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 117
+                    self.state = 118
                     self.device()
 
 
@@ -1374,19 +1373,19 @@ class CommentMacroParser ( Parser ):
             elif la_ == 12:
                 localctx = CommentMacroParser.ListGotoContext(self, localctx)
                 self.enterOuterAlt(localctx, 12)
-                self.state = 120
-                self.match(CommentMacroParser.T__11)
                 self.state = 121
-                self.target()
+                self.match(CommentMacroParser.T__11)
                 self.state = 122
-                self.match(CommentMacroParser.T__2)
+                self.target()
                 self.state = 123
+                self.match(CommentMacroParser.T__2)
+                self.state = 124
                 self.number()
-                self.state = 125
+                self.state = 126
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 124
+                    self.state = 125
                     self.device()
 
 
@@ -1395,15 +1394,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 13:
                 localctx = CommentMacroParser.ListHaltContext(self, localctx)
                 self.enterOuterAlt(localctx, 13)
-                self.state = 127
-                self.match(CommentMacroParser.T__12)
                 self.state = 128
+                self.match(CommentMacroParser.T__12)
+                self.state = 129
                 self.target()
-                self.state = 130
+                self.state = 131
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 129
+                    self.state = 130
                     self.device()
 
 
@@ -1412,15 +1411,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 14:
                 localctx = CommentMacroParser.ListAssertContext(self, localctx)
                 self.enterOuterAlt(localctx, 14)
-                self.state = 132
-                self.match(CommentMacroParser.T__13)
                 self.state = 133
+                self.match(CommentMacroParser.T__13)
+                self.state = 134
                 self.target()
-                self.state = 135
+                self.state = 136
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 134
+                    self.state = 135
                     self.device()
 
 
@@ -1429,15 +1428,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 15:
                 localctx = CommentMacroParser.ListReleseContext(self, localctx)
                 self.enterOuterAlt(localctx, 15)
-                self.state = 137
-                self.match(CommentMacroParser.T__14)
                 self.state = 138
+                self.match(CommentMacroParser.T__14)
+                self.state = 139
                 self.target()
-                self.state = 140
+                self.state = 141
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 139
+                    self.state = 140
                     self.device()
 
 
@@ -1446,15 +1445,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 16:
                 localctx = CommentMacroParser.BatchGoContext(self, localctx)
                 self.enterOuterAlt(localctx, 16)
-                self.state = 142
-                self.match(CommentMacroParser.T__15)
                 self.state = 143
+                self.match(CommentMacroParser.T__15)
+                self.state = 144
                 self.target()
-                self.state = 145
+                self.state = 146
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 144
+                    self.state = 145
                     self.device()
 
 
@@ -1463,15 +1462,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 17:
                 localctx = CommentMacroParser.BatchHaltContext(self, localctx)
                 self.enterOuterAlt(localctx, 17)
-                self.state = 147
-                self.match(CommentMacroParser.T__16)
                 self.state = 148
+                self.match(CommentMacroParser.T__16)
+                self.state = 149
                 self.target()
-                self.state = 150
+                self.state = 151
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 149
+                    self.state = 150
                     self.device()
 
 
@@ -1480,15 +1479,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 18:
                 localctx = CommentMacroParser.BatchAssertContext(self, localctx)
                 self.enterOuterAlt(localctx, 18)
-                self.state = 152
-                self.match(CommentMacroParser.T__17)
                 self.state = 153
+                self.match(CommentMacroParser.T__17)
+                self.state = 154
                 self.target()
-                self.state = 155
+                self.state = 156
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 154
+                    self.state = 155
                     self.device()
 
 
@@ -1497,15 +1496,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 19:
                 localctx = CommentMacroParser.BatchReleaseContext(self, localctx)
                 self.enterOuterAlt(localctx, 19)
-                self.state = 157
-                self.match(CommentMacroParser.T__18)
                 self.state = 158
+                self.match(CommentMacroParser.T__18)
+                self.state = 159
                 self.target()
-                self.state = 160
+                self.state = 161
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 159
+                    self.state = 160
                     self.device()
 
 
@@ -1514,15 +1513,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 20:
                 localctx = CommentMacroParser.SceneGoContext(self, localctx)
                 self.enterOuterAlt(localctx, 20)
-                self.state = 162
-                self.match(CommentMacroParser.T__19)
                 self.state = 163
+                self.match(CommentMacroParser.T__19)
+                self.state = 164
                 self.target()
-                self.state = 165
+                self.state = 166
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 164
+                    self.state = 165
                     self.device()
 
 
@@ -1531,15 +1530,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 21:
                 localctx = CommentMacroParser.SceneHaltContext(self, localctx)
                 self.enterOuterAlt(localctx, 21)
-                self.state = 167
-                self.match(CommentMacroParser.T__20)
                 self.state = 168
+                self.match(CommentMacroParser.T__20)
+                self.state = 169
                 self.target()
-                self.state = 170
+                self.state = 171
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 169
+                    self.state = 170
                     self.device()
 
 
@@ -1548,15 +1547,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 22:
                 localctx = CommentMacroParser.SceneAssertContext(self, localctx)
                 self.enterOuterAlt(localctx, 22)
-                self.state = 172
-                self.match(CommentMacroParser.T__21)
                 self.state = 173
+                self.match(CommentMacroParser.T__21)
+                self.state = 174
                 self.target()
-                self.state = 175
+                self.state = 176
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 174
+                    self.state = 175
                     self.device()
 
 
@@ -1565,15 +1564,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 23:
                 localctx = CommentMacroParser.SceneReleaseContext(self, localctx)
                 self.enterOuterAlt(localctx, 23)
-                self.state = 177
-                self.match(CommentMacroParser.T__22)
                 self.state = 178
+                self.match(CommentMacroParser.T__22)
+                self.state = 179
                 self.target()
-                self.state = 180
+                self.state = 181
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 179
+                    self.state = 180
                     self.device()
 
 
@@ -1582,15 +1581,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 24:
                 localctx = CommentMacroParser.PageChangeContext(self, localctx)
                 self.enterOuterAlt(localctx, 24)
-                self.state = 182
-                self.match(CommentMacroParser.T__23)
                 self.state = 183
+                self.match(CommentMacroParser.T__23)
+                self.state = 184
                 self.number()
-                self.state = 185
+                self.state = 186
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 184
+                    self.state = 185
                     self.device()
 
 
@@ -1599,15 +1598,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 25:
                 localctx = CommentMacroParser.PageNextContext(self, localctx)
                 self.enterOuterAlt(localctx, 25)
-                self.state = 187
-                self.match(CommentMacroParser.T__23)
                 self.state = 188
+                self.match(CommentMacroParser.T__23)
+                self.state = 189
                 self.match(CommentMacroParser.T__24)
-                self.state = 190
+                self.state = 191
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 189
+                    self.state = 190
                     self.device()
 
 
@@ -1616,15 +1615,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 26:
                 localctx = CommentMacroParser.PagePrevContext(self, localctx)
                 self.enterOuterAlt(localctx, 26)
-                self.state = 192
-                self.match(CommentMacroParser.T__23)
                 self.state = 193
+                self.match(CommentMacroParser.T__23)
+                self.state = 194
                 self.match(CommentMacroParser.T__25)
-                self.state = 195
+                self.state = 196
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 194
+                    self.state = 195
                     self.device()
 
 
@@ -1633,15 +1632,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 27:
                 localctx = CommentMacroParser.RecallViewContext(self, localctx)
                 self.enterOuterAlt(localctx, 27)
-                self.state = 197
-                self.match(CommentMacroParser.T__26)
                 self.state = 198
+                self.match(CommentMacroParser.T__26)
+                self.state = 199
                 self.number()
-                self.state = 200
+                self.state = 201
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 199
+                    self.state = 200
                     self.device()
 
 
@@ -1650,24 +1649,24 @@ class CommentMacroParser ( Parser ):
             elif la_ == 28:
                 localctx = CommentMacroParser.NodeResetContext(self, localctx)
                 self.enterOuterAlt(localctx, 28)
-                self.state = 202
-                self.match(CommentMacroParser.T__27)
                 self.state = 203
+                self.match(CommentMacroParser.T__27)
+                self.state = 204
                 self.device()
                 pass
 
             elif la_ == 29:
                 localctx = CommentMacroParser.MacroGoContext(self, localctx)
                 self.enterOuterAlt(localctx, 29)
-                self.state = 204
-                self.match(CommentMacroParser.T__28)
                 self.state = 205
+                self.match(CommentMacroParser.T__28)
+                self.state = 206
                 self.target()
-                self.state = 207
+                self.state = 208
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 206
+                    self.state = 207
                     self.device()
 
 
@@ -1676,15 +1675,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 30:
                 localctx = CommentMacroParser.MacroHaltContext(self, localctx)
                 self.enterOuterAlt(localctx, 30)
-                self.state = 209
-                self.match(CommentMacroParser.T__29)
                 self.state = 210
+                self.match(CommentMacroParser.T__29)
+                self.state = 211
                 self.target()
-                self.state = 212
+                self.state = 213
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 211
+                    self.state = 212
                     self.device()
 
 
@@ -1693,15 +1692,15 @@ class CommentMacroParser ( Parser ):
             elif la_ == 31:
                 localctx = CommentMacroParser.MacroStopContext(self, localctx)
                 self.enterOuterAlt(localctx, 31)
-                self.state = 214
-                self.match(CommentMacroParser.T__30)
                 self.state = 215
+                self.match(CommentMacroParser.T__30)
+                self.state = 216
                 self.target()
-                self.state = 217
+                self.state = 218
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
-                    self.state = 216
+                    self.state = 217
                     self.device()
 
 
@@ -1710,9 +1709,9 @@ class CommentMacroParser ( Parser ):
             elif la_ == 32:
                 localctx = CommentMacroParser.WaitContext(self, localctx)
                 self.enterOuterAlt(localctx, 32)
-                self.state = 219
-                self.match(CommentMacroParser.T__31)
                 self.state = 220
+                self.match(CommentMacroParser.T__31)
+                self.state = 221
                 self.number()
                 pass
 
@@ -1758,9 +1757,9 @@ class CommentMacroParser ( Parser ):
         self.enterRule(localctx, 6, self.RULE_time)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 223
-            self.match(CommentMacroParser.TIME)
             self.state = 224
+            self.match(CommentMacroParser.TIME)
+            self.state = 225
             self.number()
         except RecognitionException as re:
             localctx.exception = re
@@ -1804,9 +1803,9 @@ class CommentMacroParser ( Parser ):
         self.enterRule(localctx, 8, self.RULE_device)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 226
-            self.nodeType()
             self.state = 227
+            self.nodeType()
+            self.state = 228
             self.number()
         except RecognitionException as re:
             localctx.exception = re
@@ -1852,7 +1851,7 @@ class CommentMacroParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 229
+            self.state = 230
             _la = self._input.LA(1)
             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0)):
                 self._errHandler.recoverInline(self)
@@ -1908,30 +1907,30 @@ class CommentMacroParser ( Parser ):
         self.enterRule(localctx, 12, self.RULE_target)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 233
+            self.state = 234
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
             if la_ == 1:
-                self.state = 231
+                self.state = 232
                 self.number()
                 pass
 
             elif la_ == 2:
-                self.state = 232
+                self.state = 233
                 self.span()
                 pass
 
 
-            self.state = 239
+            self.state = 240
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,44,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 235
-                    self.match(CommentMacroParser.T__32)
                     self.state = 236
+                    self.match(CommentMacroParser.T__32)
+                    self.state = 237
                     self.target() 
-                self.state = 241
+                self.state = 242
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,44,self._ctx)
 
@@ -1981,11 +1980,11 @@ class CommentMacroParser ( Parser ):
         self.enterRule(localctx, 14, self.RULE_span)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 242
-            localctx.n1 = self.number()
             self.state = 243
-            self.match(CommentMacroParser.THRU)
+            localctx.n1 = self.number()
             self.state = 244
+            self.match(CommentMacroParser.THRU)
+            self.state = 245
             localctx.n2 = self.number()
         except RecognitionException as re:
             localctx.exception = re
@@ -2024,7 +2023,7 @@ class CommentMacroParser ( Parser ):
         self.enterRule(localctx, 16, self.RULE_number)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 246
+            self.state = 247
             self.match(CommentMacroParser.NUMBER)
         except RecognitionException as re:
             localctx.exception = re