From: leo <leo@ae02f08e-27ec-0310-ae8c-8ba02fe2eafd>
Date: Tue, 17 Feb 2009 15:24:06 +0000 (+0000)
Subject: git-svn-id: http://www.xerial.org/svn/project/XerialJ/trunk/xerial-core@2985 ae02f08e... 
X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=1638cae2cd0d23f95c7fff0e6b34fc57e459696b;p=xerial%2Fxerial-core.git

git-svn-id: xerial.org/svn/project/XerialJ/trunk/xerial-core@2985 ae02f08e-27ec-0310-ae8c-8ba02fe2eafd
---

diff --git a/src/main/java/org/xerial/silk/impl/Silk.g b/src/main/java/org/xerial/silk/impl/Silk.g
index 74744fd..3be2b4e 100644
--- a/src/main/java/org/xerial/silk/impl/Silk.g
+++ b/src/main/java/org/xerial/silk/impl/Silk.g
@@ -28,7 +28,7 @@ options
 	output=AST;
 	// some lexer & parser options
 	// number of look-ahead characters 
-	//k=3;	
+	k=3;	
 	//backtrack=true;
 }
 tokens {
@@ -151,8 +151,8 @@ DataLine: { isHead() }?
 	=> WhiteSpace* DataLineBody (LineBreak|LineComment) { setText($DataLineBody.text); };
 
 LParen: '(' { transit(Symbol.EnterParen); };  
-RParen:	')';
-Comma: 	',';
+RParen:	')' { transit(Symbol.LeaveParen); };
+Comma: 	','; 
 Colon:	':' { transit(Symbol.Colon); } ;
 Seq: 	'>';
 TabSeq:	'|';
@@ -189,10 +189,10 @@ fragment FlowIndicator:  '[' | ']' | '{' | '}';
 fragment Indicator:  FlowIndicator | ScopeIndicator | ',' | '-' | ':' | '#' | '>' | '|' | '\'' | '"' | '@' | '%' | '\\';	
 
 
-fragment PlainUnsafeChar: '"'| '\\' | LineBreakChar | WhiteSpace | '#' | ScopeIndicator;
+fragment PlainUnsafeChar: '"'| '\\' | LineBreakChar | '#' ;
 
-fragment PlainSafeKey: ~(PlainUnsafeChar | FlowIndicator | ',' | ':' | '>' | '*'); 
-fragment PlainSafeIn: ~(PlainUnsafeChar | ',');
+fragment PlainSafeKey: ~(PlainUnsafeChar | ScopeIndicator | FlowIndicator | ',' | ':' | '>' | '*'); 
+fragment PlainSafeIn: ~(PlainUnsafeChar | ScopeIndicator | ',');
 fragment PlainSafeOut: ~(PlainUnsafeChar);
 
 
@@ -201,9 +201,8 @@ fragment PlainSafe
 	| { isInValue() }? => PlainSafeIn 
 	| { isOutValue() }? => PlainSafeOut
 	;
-
  
-PlainOneLine: PlainFirst (WhiteSpace* PlainSafe)* { transit(Symbol.LeaveValue); }
+PlainOneLine: PlainFirst (WhiteSpace* PlainSafe)* { transit(Symbol.LeaveValue); }  
 		;
 
 JSON
@@ -231,7 +230,7 @@ JSON
 	}  
 	;
 	 
-Separation: { currentState() != State.INIT }? WhiteSpace+ { $channel=HIDDEN; };
+Separation: { !isHead() }? WhiteSpace+ { $channel=HIDDEN; };
 
 WhiteSpace
 	:	(' ' | '\t') 
@@ -261,8 +260,8 @@ nodeValue
 	| JSON 
 	; 
 
-nodeItem: nodeName dataType? (Colon nodeValue)? (LParen attributeList RParen)?  plural?
-	-> Name[$nodeName.text] nodeValue? dataType? plural? attributeList? 
+nodeItem: nodeName dataType? (LParen attributeList RParen)? plural? (Colon nodeValue)? 
+	-> Name[$nodeName.text.trim()] nodeValue? dataType? plural? attributeList? 
 	;
 
 
@@ -289,7 +288,7 @@ function
 	: NodeIndent function_i
 	-> ^(Function NodeIndent function_i)
 	| FunctionIndent PlainOneLine LParen (functionArg (Comma functionArg)*)? RParen
-	-> ^(Function NodeIndent[$FunctionIndent.text] Name[$PlainOneLine.text] functionArg*)
+	-> ^(Function NodeIndent[$FunctionIndent.text] Name[$PlainOneLine.text.trim()] functionArg*)
 	;
 
 
@@ -300,7 +299,7 @@ function_i: At PlainOneLine LParen (functionArg (Comma functionArg)*)? RParen
 
 functionArg
 	: nodeValue -> Argument[$functionArg.text]
-	| nodeName Colon nodeValue -> ^(KeyValuePair Name[$nodeName.text] nodeValue)
+	| nodeName Colon nodeValue -> ^(KeyValuePair Name[$nodeName.text.trim()] nodeValue)
 	;
 
 
diff --git a/src/main/java/org/xerial/silk/impl/SilkLexer.java b/src/main/java/org/xerial/silk/impl/SilkLexer.java
index da53289..f927547 100644
--- a/src/main/java/org/xerial/silk/impl/SilkLexer.java
+++ b/src/main/java/org/xerial/silk/impl/SilkLexer.java
@@ -1,4 +1,4 @@
-// $ANTLR 3.1.1 F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g 2009-02-16 16:30:51
+// $ANTLR 3.1.1 c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g 2009-02-18 00:23:21
 
 /*--------------------------------------------------------------------------
  *  Copyright 2009 Taro L. Saito
@@ -118,18 +118,18 @@ public class SilkLexer extends Lexer {
         super(input,state);
 
     }
-    public String getGrammarFileName() { return "F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g"; }
+    public String getGrammarFileName() { return "c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g"; }
 
     // $ANTLR start "LineComment"
     public final void mLineComment() throws RecognitionException {
         try {
             int _type = LineComment;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:133:12: ( '#' (~ ( '\\n' | '\\r' ) )* '\\r' '\\n' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:133:14: '#' (~ ( '\\n' | '\\r' ) )* '\\r' '\\n'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:133:12: ( '#' (~ ( '\\n' | '\\r' ) )* '\\r' '\\n' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:133:14: '#' (~ ( '\\n' | '\\r' ) )* '\\r' '\\n'
             {
             match('#'); 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:133:18: (~ ( '\\n' | '\\r' ) )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:133:18: (~ ( '\\n' | '\\r' ) )*
             loop1:
             do {
                 int alt1=2;
@@ -142,7 +142,7 @@ public class SilkLexer extends Lexer {
 
                 switch (alt1) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:133:18: ~ ( '\\n' | '\\r' )
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:133:18: ~ ( '\\n' | '\\r' )
             	    {
             	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
             	        input.consume();
@@ -181,11 +181,11 @@ public class SilkLexer extends Lexer {
         try {
             int _type = Preamble;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:9: ( '%' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:11: '%' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:9: ( '%' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:11: '%' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
             {
             match('%'); 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:15: (~ ( '\\n' | '\\r' ) )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:15: (~ ( '\\n' | '\\r' ) )*
             loop2:
             do {
                 int alt2=2;
@@ -198,7 +198,7 @@ public class SilkLexer extends Lexer {
 
                 switch (alt2) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:15: ~ ( '\\n' | '\\r' )
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:15: ~ ( '\\n' | '\\r' )
             	    {
             	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
             	        input.consume();
@@ -218,7 +218,7 @@ public class SilkLexer extends Lexer {
                 }
             } while (true);
 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:29: ( '\\r' )?
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:29: ( '\\r' )?
             int alt3=2;
             int LA3_0 = input.LA(1);
 
@@ -227,7 +227,7 @@ public class SilkLexer extends Lexer {
             }
             switch (alt3) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:29: '\\r'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:134:29: '\\r'
                     {
                     match('\r'); 
 
@@ -251,8 +251,8 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "LineBreakChar"
     public final void mLineBreakChar() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:137:23: ( '\\n' | '\\r' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:137:23: ( '\\n' | '\\r' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
             {
             if ( input.LA(1)=='\n'||input.LA(1)=='\r' ) {
                 input.consume();
@@ -277,10 +277,10 @@ public class SilkLexer extends Lexer {
         try {
             int _type = LineBreak;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:2: ( ( '\\r' '\\n' | '\\r' | '\\n' ) )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:4: ( '\\r' '\\n' | '\\r' | '\\n' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:2: ( ( '\\r' '\\n' | '\\r' | '\\n' ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:4: ( '\\r' '\\n' | '\\r' | '\\n' )
             {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:4: ( '\\r' '\\n' | '\\r' | '\\n' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:4: ( '\\r' '\\n' | '\\r' | '\\n' )
             int alt4=3;
             int LA4_0 = input.LA(1);
 
@@ -304,7 +304,7 @@ public class SilkLexer extends Lexer {
             }
             switch (alt4) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:5: '\\r' '\\n'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:5: '\\r' '\\n'
                     {
                     match('\r'); 
                     match('\n'); 
@@ -312,14 +312,14 @@ public class SilkLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:17: '\\r'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:17: '\\r'
                     {
                     match('\r'); 
 
                     }
                     break;
                 case 3 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:24: '\\n'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:24: '\\n'
                     {
                     match('\n'); 
 
@@ -345,13 +345,13 @@ public class SilkLexer extends Lexer {
         try {
             int _type = NodeIndent;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:145:11: ({...}? ( ' ' )* '-' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:145:13: {...}? ( ' ' )* '-'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:145:11: ({...}? ( ' ' )* '-' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:145:13: {...}? ( ' ' )* '-'
             {
             if ( !(( isHead() )) ) {
                 throw new FailedPredicateException(input, "NodeIndent", " isHead() ");
             }
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:145:27: ( ' ' )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:145:27: ( ' ' )*
             loop5:
             do {
                 int alt5=2;
@@ -364,7 +364,7 @@ public class SilkLexer extends Lexer {
 
                 switch (alt5) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:145:28: ' '
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:145:28: ' '
             	    {
             	    match(' '); 
 
@@ -394,13 +394,13 @@ public class SilkLexer extends Lexer {
         try {
             int _type = FunctionIndent;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:146:15: ({...}? => ( ' ' )* '@' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:146:17: {...}? => ( ' ' )* '@'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:146:15: ({...}? => ( ' ' )* '@' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:146:17: {...}? => ( ' ' )* '@'
             {
             if ( !(( isHead() )) ) {
                 throw new FailedPredicateException(input, "FunctionIndent", " isHead() ");
             }
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:146:34: ( ' ' )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:146:34: ( ' ' )*
             loop6:
             do {
                 int alt6=2;
@@ -413,7 +413,7 @@ public class SilkLexer extends Lexer {
 
                 switch (alt6) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:146:35: ' '
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:146:35: ' '
             	    {
             	    match(' '); 
 
@@ -443,13 +443,13 @@ public class SilkLexer extends Lexer {
         try {
             int _type = BlankLine;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:147:10: ({...}? ( WhiteSpace )* LineBreak )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:147:12: {...}? ( WhiteSpace )* LineBreak
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:147:10: ({...}? ( WhiteSpace )* LineBreak )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:147:12: {...}? ( WhiteSpace )* LineBreak
             {
             if ( !(( isHead() )) ) {
                 throw new FailedPredicateException(input, "BlankLine", " isHead() ");
             }
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:147:26: ( WhiteSpace )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:147:26: ( WhiteSpace )*
             loop7:
             do {
                 int alt7=2;
@@ -462,7 +462,7 @@ public class SilkLexer extends Lexer {
 
                 switch (alt7) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:147:26: WhiteSpace
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:147:26: WhiteSpace
             	    {
             	    mWhiteSpace(); 
 
@@ -489,8 +489,8 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "DataLineBody"
     public final void mDataLineBody() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:22: (~ ( '-' | '%' | '#' | '@' | WhiteSpace | LineBreakChar ) (~ ( '#' | '\\n' | '\\r' ) )* )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:24: ~ ( '-' | '%' | '#' | '@' | WhiteSpace | LineBreakChar ) (~ ( '#' | '\\n' | '\\r' ) )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:22: (~ ( '-' | '%' | '#' | '@' | WhiteSpace | LineBreakChar ) (~ ( '#' | '\\n' | '\\r' ) )* )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:24: ~ ( '-' | '%' | '#' | '@' | WhiteSpace | LineBreakChar ) (~ ( '#' | '\\n' | '\\r' ) )*
             {
             if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||(input.LA(1)>='!' && input.LA(1)<='\"')||input.LA(1)=='$'||(input.LA(1)>='&' && input.LA(1)<=',')||(input.LA(1)>='.' && input.LA(1)<='?')||(input.LA(1)>='A' && input.LA(1)<='\uFFFF') ) {
                 input.consume();
@@ -501,7 +501,7 @@ public class SilkLexer extends Lexer {
                 recover(mse);
                 throw mse;}
 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:78: (~ ( '#' | '\\n' | '\\r' ) )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:78: (~ ( '#' | '\\n' | '\\r' ) )*
             loop8:
             do {
                 int alt8=2;
@@ -514,7 +514,7 @@ public class SilkLexer extends Lexer {
 
                 switch (alt8) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:78: ~ ( '#' | '\\n' | '\\r' )
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:78: ~ ( '#' | '\\n' | '\\r' )
             	    {
             	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\"')||(input.LA(1)>='$' && input.LA(1)<='\uFFFF') ) {
             	        input.consume();
@@ -550,13 +550,13 @@ public class SilkLexer extends Lexer {
             int _channel = DEFAULT_TOKEN_CHANNEL;
             Token DataLineBody1=null;
 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:150:9: ({...}? => ( WhiteSpace )* DataLineBody ( LineBreak | LineComment ) )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:150:11: {...}? => ( WhiteSpace )* DataLineBody ( LineBreak | LineComment )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:150:9: ({...}? => ( WhiteSpace )* DataLineBody ( LineBreak | LineComment ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:150:11: {...}? => ( WhiteSpace )* DataLineBody ( LineBreak | LineComment )
             {
             if ( !(( isHead() )) ) {
                 throw new FailedPredicateException(input, "DataLine", " isHead() ");
             }
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:5: ( WhiteSpace )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:5: ( WhiteSpace )*
             loop9:
             do {
                 int alt9=2;
@@ -569,7 +569,7 @@ public class SilkLexer extends Lexer {
 
                 switch (alt9) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:5: WhiteSpace
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:5: WhiteSpace
             	    {
             	    mWhiteSpace(); 
 
@@ -584,7 +584,7 @@ public class SilkLexer extends Lexer {
             int DataLineBody1Start229 = getCharIndex();
             mDataLineBody(); 
             DataLineBody1 = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, DataLineBody1Start229, getCharIndex()-1);
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:30: ( LineBreak | LineComment )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:30: ( LineBreak | LineComment )
             int alt10=2;
             int LA10_0 = input.LA(1);
 
@@ -602,14 +602,14 @@ public class SilkLexer extends Lexer {
             }
             switch (alt10) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:31: LineBreak
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:31: LineBreak
                     {
                     mLineBreak(); 
 
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:41: LineComment
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:41: LineComment
                     {
                     mLineComment(); 
 
@@ -635,8 +635,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = LParen;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:153:7: ( '(' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:153:9: '('
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:153:7: ( '(' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:153:9: '('
             {
             match('('); 
              transit(Symbol.EnterParen); 
@@ -656,10 +656,11 @@ public class SilkLexer extends Lexer {
         try {
             int _type = RParen;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:154:7: ( ')' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:154:9: ')'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:154:7: ( ')' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:154:9: ')'
             {
             match(')'); 
+             transit(Symbol.LeaveParen); 
 
             }
 
@@ -676,8 +677,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = Comma;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:155:6: ( ',' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:155:9: ','
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:155:6: ( ',' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:155:9: ','
             {
             match(','); 
 
@@ -696,8 +697,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = Colon;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:156:6: ( ':' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:156:8: ':'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:156:6: ( ':' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:156:8: ':'
             {
             match(':'); 
              transit(Symbol.Colon); 
@@ -717,8 +718,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = Seq;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:157:4: ( '>' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:157:7: '>'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:157:4: ( '>' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:157:7: '>'
             {
             match('>'); 
 
@@ -737,8 +738,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = TabSeq;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:158:7: ( '|' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:158:9: '|'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:158:7: ( '|' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:158:9: '|'
             {
             match('|'); 
 
@@ -757,8 +758,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = Star;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:159:5: ( '*' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:159:8: '*'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:159:5: ( '*' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:159:8: '*'
             {
             match('*'); 
 
@@ -777,8 +778,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = At;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:160:3: ( '@' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:160:6: '@'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:160:3: ( '@' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:160:6: '@'
             {
             match('@'); 
 
@@ -797,8 +798,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = Plus;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:161:5: ( '+' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:161:7: '+'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:161:5: ( '+' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:161:7: '+'
             {
             match('+'); 
 
@@ -817,8 +818,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = LBracket;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:162:9: ( '[' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:162:11: '['
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:162:9: ( '[' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:162:11: '['
             {
             match('['); 
              transit(Symbol.EnterParen); 
@@ -838,8 +839,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = RBracket;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:163:9: ( ']' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:163:11: ']'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:163:9: ( ']' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:163:11: ']'
             {
             match(']'); 
 
@@ -858,8 +859,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = Question;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:164:9: ( '?' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:164:11: '?'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:164:9: ( '?' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:164:11: '?'
             {
             match('?'); 
 
@@ -876,8 +877,8 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "Digit"
     public final void mDigit() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:166:15: ( '0' .. '9' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:166:17: '0' .. '9'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:166:15: ( '0' .. '9' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:166:17: '0' .. '9'
             {
             matchRange('0','9'); 
 
@@ -892,8 +893,8 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "Letter"
     public final void mLetter() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:167:16: ( 'A' .. 'F' | 'a' .. 'f' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:167:16: ( 'A' .. 'F' | 'a' .. 'f' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
             {
             if ( (input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
                 input.consume();
@@ -916,8 +917,8 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "HexDigit"
     public final void mHexDigit() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:168:18: ( Digit | Letter )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:168:18: ( Digit | Letter )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
             {
             if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
                 input.consume();
@@ -940,8 +941,8 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "UnicodeChar"
     public final void mUnicodeChar() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:169:21: (~ ( '\"' | '\\\\' | LineBreakChar ) )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:169:23: ~ ( '\"' | '\\\\' | LineBreakChar )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:169:21: (~ ( '\"' | '\\\\' | LineBreakChar ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:169:23: ~ ( '\"' | '\\\\' | LineBreakChar )
             {
             if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                 input.consume();
@@ -964,11 +965,11 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "EscapeSequence"
     public final void mEscapeSequence() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:2: ( '\\\\' ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit ) )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:4: '\\\\' ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:2: ( '\\\\' ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:4: '\\\\' ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit )
             {
             match('\\'); 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:9: ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:9: ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit )
             int alt11=9;
             switch ( input.LA(1) ) {
             case '\"':
@@ -1025,63 +1026,63 @@ public class SilkLexer extends Lexer {
 
             switch (alt11) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:10: '\\\"'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:10: '\\\"'
                     {
                     match('\"'); 
 
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:17: '\\\\'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:17: '\\\\'
                     {
                     match('\\'); 
 
                     }
                     break;
                 case 3 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:24: '/'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:24: '/'
                     {
                     match('/'); 
 
                     }
                     break;
                 case 4 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:30: 'b'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:30: 'b'
                     {
                     match('b'); 
 
                     }
                     break;
                 case 5 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:36: 'f'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:36: 'f'
                     {
                     match('f'); 
 
                     }
                     break;
                 case 6 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:42: 'n'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:42: 'n'
                     {
                     match('n'); 
 
                     }
                     break;
                 case 7 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:48: 'r'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:48: 'r'
                     {
                     match('r'); 
 
                     }
                     break;
                 case 8 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:54: 't'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:54: 't'
                     {
                     match('t'); 
 
                     }
                     break;
                 case 9 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:60: 'u' HexDigit HexDigit HexDigit HexDigit
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:171:60: 'u' HexDigit HexDigit HexDigit HexDigit
                     {
                     match('u'); 
                     mHexDigit(); 
@@ -1106,7 +1107,7 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "StringChar"
     public final void mStringChar() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:175:21: ( UnicodeChar | EscapeSequence )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:175:21: ( UnicodeChar | EscapeSequence )
             int alt12=2;
             int LA12_0 = input.LA(1);
 
@@ -1124,14 +1125,14 @@ public class SilkLexer extends Lexer {
             }
             switch (alt12) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:175:24: UnicodeChar
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:175:24: UnicodeChar
                     {
                     mUnicodeChar(); 
 
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:175:38: EscapeSequence
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:175:38: EscapeSequence
                     {
                     mEscapeSequence(); 
 
@@ -1148,8 +1149,8 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "NonSpaceChar"
     public final void mNonSpaceChar() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:176:22: (~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace ) )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:176:24: ~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:176:22: (~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:176:24: ~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace )
             {
             if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||input.LA(1)=='!'||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                 input.consume();
@@ -1172,10 +1173,10 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "StringChar_s"
     public final void mStringChar_s() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:178:22: ( ( StringChar )* )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:178:24: ( StringChar )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:178:22: ( ( StringChar )* )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:178:24: ( StringChar )*
             {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:178:24: ( StringChar )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:178:24: ( StringChar )*
             loop13:
             do {
                 int alt13=2;
@@ -1188,7 +1189,7 @@ public class SilkLexer extends Lexer {
 
                 switch (alt13) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:178:24: StringChar
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:178:24: StringChar
             	    {
             	    mStringChar(); 
 
@@ -1216,13 +1217,13 @@ public class SilkLexer extends Lexer {
             int _channel = DEFAULT_TOKEN_CHANNEL;
             Token s=null;
 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:179:7: ( '\"' s= StringChar_s '\"' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:179:9: '\"' s= StringChar_s '\"'
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:179:7: ( '\"' s= StringChar_s '\"' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:179:9: '\"' s= StringChar_s '\"'
             {
             match('\"'); 
-            int sStart523 = getCharIndex();
+            int sStart526 = getCharIndex();
             mStringChar_s(); 
-            s = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, sStart523, getCharIndex()-1);
+            s = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, sStart526, getCharIndex()-1);
             match('\"'); 
              setText((s!=null?s.getText():null)); 
 
@@ -1239,7 +1240,7 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "PlainFirst"
     public final void mPlainFirst() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:183:2: (~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace | Indicator ) | {...}? => ( ':' | '?' ) NonSpaceChar )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:183:2: (~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace | Indicator ) | {...}? => ( ':' | '?' ) NonSpaceChar )
             int alt14=2;
             int LA14_0 = input.LA(1);
 
@@ -1266,7 +1267,7 @@ public class SilkLexer extends Lexer {
             }
             switch (alt14) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:183:4: ~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace | Indicator )
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:183:4: ~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace | Indicator )
                     {
                     if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||input.LA(1)=='!'||input.LA(1)=='$'||input.LA(1)=='&'||(input.LA(1)>='*' && input.LA(1)<='+')||(input.LA(1)>='.' && input.LA(1)<='9')||(input.LA(1)>=';' && input.LA(1)<='=')||input.LA(1)=='?'||(input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='^' && input.LA(1)<='z')||(input.LA(1)>='~' && input.LA(1)<='\uFFFF') ) {
                         input.consume();
@@ -1281,7 +1282,7 @@ public class SilkLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:184:4: {...}? => ( ':' | '?' ) NonSpaceChar
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:184:4: {...}? => ( ':' | '?' ) NonSpaceChar
                     {
                     if ( !(( isValue() )) ) {
                         throw new FailedPredicateException(input, "PlainFirst", " isValue() ");
@@ -1310,8 +1311,8 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "ScopeIndicator"
     public final void mScopeIndicator() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:187:24: ( '(' | ')' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:187:24: ( '(' | ')' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
             {
             if ( (input.LA(1)>='(' && input.LA(1)<=')') ) {
                 input.consume();
@@ -1334,8 +1335,8 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "FlowIndicator"
     public final void mFlowIndicator() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:188:23: ( '[' | ']' | '{' | '}' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:188:23: ( '[' | ']' | '{' | '}' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
             {
             if ( input.LA(1)=='['||input.LA(1)==']'||input.LA(1)=='{'||input.LA(1)=='}' ) {
                 input.consume();
@@ -1358,8 +1359,8 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "Indicator"
     public final void mIndicator() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:189:19: ( FlowIndicator | ScopeIndicator | ',' | '-' | ':' | '#' | '>' | '|' | '\\'' | '\"' | '@' | '%' | '\\\\' )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:189:19: ( FlowIndicator | ScopeIndicator | ',' | '-' | ':' | '#' | '>' | '|' | '\\'' | '\"' | '@' | '%' | '\\\\' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
             {
             if ( (input.LA(1)>='\"' && input.LA(1)<='#')||input.LA(1)=='%'||(input.LA(1)>='\'' && input.LA(1)<=')')||(input.LA(1)>=',' && input.LA(1)<='-')||input.LA(1)==':'||input.LA(1)=='>'||input.LA(1)=='@'||(input.LA(1)>='[' && input.LA(1)<=']')||(input.LA(1)>='{' && input.LA(1)<='}') ) {
                 input.consume();
@@ -1382,10 +1383,10 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "PlainUnsafeChar"
     public final void mPlainUnsafeChar() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:192:25: ( '\"' | '\\\\' | LineBreakChar | WhiteSpace | '#' | ScopeIndicator )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:192:25: ( '\"' | '\\\\' | LineBreakChar | '#' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
             {
-            if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' '||(input.LA(1)>='\"' && input.LA(1)<='#')||(input.LA(1)>='(' && input.LA(1)<=')')||input.LA(1)=='\\' ) {
+            if ( input.LA(1)=='\n'||input.LA(1)=='\r'||(input.LA(1)>='\"' && input.LA(1)<='#')||input.LA(1)=='\\' ) {
                 input.consume();
 
             }
@@ -1406,10 +1407,10 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "PlainSafeKey"
     public final void mPlainSafeKey() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:194:22: (~ ( PlainUnsafeChar | FlowIndicator | ',' | ':' | '>' | '*' ) )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:194:24: ~ ( PlainUnsafeChar | FlowIndicator | ',' | ':' | '>' | '*' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:194:22: (~ ( PlainUnsafeChar | ScopeIndicator | FlowIndicator | ',' | ':' | '>' | '*' ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:194:24: ~ ( PlainUnsafeChar | ScopeIndicator | FlowIndicator | ',' | ':' | '>' | '*' )
             {
-            if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||input.LA(1)=='!'||(input.LA(1)>='$' && input.LA(1)<='\'')||input.LA(1)=='+'||(input.LA(1)>='-' && input.LA(1)<='9')||(input.LA(1)>=';' && input.LA(1)<='=')||(input.LA(1)>='?' && input.LA(1)<='Z')||(input.LA(1)>='^' && input.LA(1)<='z')||input.LA(1)=='|'||(input.LA(1)>='~' && input.LA(1)<='\uFFFF') ) {
+            if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='!')||(input.LA(1)>='$' && input.LA(1)<='\'')||input.LA(1)=='+'||(input.LA(1)>='-' && input.LA(1)<='9')||(input.LA(1)>=';' && input.LA(1)<='=')||(input.LA(1)>='?' && input.LA(1)<='Z')||(input.LA(1)>='^' && input.LA(1)<='z')||input.LA(1)=='|'||(input.LA(1)>='~' && input.LA(1)<='\uFFFF') ) {
                 input.consume();
 
             }
@@ -1430,10 +1431,10 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "PlainSafeIn"
     public final void mPlainSafeIn() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:195:21: (~ ( PlainUnsafeChar | ',' ) )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:195:23: ~ ( PlainUnsafeChar | ',' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:195:21: (~ ( PlainUnsafeChar | ScopeIndicator | ',' ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:195:23: ~ ( PlainUnsafeChar | ScopeIndicator | ',' )
             {
-            if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||input.LA(1)=='!'||(input.LA(1)>='$' && input.LA(1)<='\'')||(input.LA(1)>='*' && input.LA(1)<='+')||(input.LA(1)>='-' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+            if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='!')||(input.LA(1)>='$' && input.LA(1)<='\'')||(input.LA(1)>='*' && input.LA(1)<='+')||(input.LA(1)>='-' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                 input.consume();
 
             }
@@ -1454,10 +1455,10 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "PlainSafeOut"
     public final void mPlainSafeOut() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:196:22: (~ ( PlainUnsafeChar ) )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:196:24: ~ ( PlainUnsafeChar )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:196:22: (~ ( PlainUnsafeChar ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:196:24: ~ ( PlainUnsafeChar )
             {
-            if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||input.LA(1)=='!'||(input.LA(1)>='$' && input.LA(1)<='\'')||(input.LA(1)>='*' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+            if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='!')||(input.LA(1)>='$' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                 input.consume();
 
             }
@@ -1478,11 +1479,11 @@ public class SilkLexer extends Lexer {
     // $ANTLR start "PlainSafe"
     public final void mPlainSafe() throws RecognitionException {
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:200:2: ({...}? => PlainSafeKey | {...}? => PlainSafeIn | {...}? => PlainSafeOut )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:200:2: ({...}? => PlainSafeKey | {...}? => PlainSafeIn | {...}? => PlainSafeOut )
             int alt15=3;
             int LA15_0 = input.LA(1);
 
-            if ( ((LA15_0>='\u0000' && LA15_0<='\b')||(LA15_0>='\u000B' && LA15_0<='\f')||(LA15_0>='\u000E' && LA15_0<='\u001F')||LA15_0=='!'||(LA15_0>='$' && LA15_0<='\'')||LA15_0=='+'||(LA15_0>='-' && LA15_0<='9')||(LA15_0>=';' && LA15_0<='=')||(LA15_0>='?' && LA15_0<='Z')||(LA15_0>='^' && LA15_0<='z')||LA15_0=='|'||(LA15_0>='~' && LA15_0<='\uFFFF')) && ((( isInValue() )||( isOutValue() )||( isKey() )))) {
+            if ( ((LA15_0>='\u0000' && LA15_0<='\t')||(LA15_0>='\u000B' && LA15_0<='\f')||(LA15_0>='\u000E' && LA15_0<='!')||(LA15_0>='$' && LA15_0<='\'')||LA15_0=='+'||(LA15_0>='-' && LA15_0<='9')||(LA15_0>=';' && LA15_0<='=')||(LA15_0>='?' && LA15_0<='Z')||(LA15_0>='^' && LA15_0<='z')||LA15_0=='|'||(LA15_0>='~' && LA15_0<='\uFFFF')) && ((( isInValue() )||( isOutValue() )||( isKey() )))) {
                 int LA15_1 = input.LA(2);
 
                 if ( (( isKey() )) ) {
@@ -1517,7 +1518,7 @@ public class SilkLexer extends Lexer {
                     throw nvae;
                 }
             }
-            else if ( (LA15_0==',') && (( isOutValue() ))) {
+            else if ( ((LA15_0>='(' && LA15_0<=')')||LA15_0==',') && (( isOutValue() ))) {
                 alt15=3;
             }
             else {
@@ -1528,7 +1529,7 @@ public class SilkLexer extends Lexer {
             }
             switch (alt15) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:200:4: {...}? => PlainSafeKey
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:200:4: {...}? => PlainSafeKey
                     {
                     if ( !(( isKey() )) ) {
                         throw new FailedPredicateException(input, "PlainSafe", " isKey() ");
@@ -1538,7 +1539,7 @@ public class SilkLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:201:4: {...}? => PlainSafeIn
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:201:4: {...}? => PlainSafeIn
                     {
                     if ( !(( isInValue() )) ) {
                         throw new FailedPredicateException(input, "PlainSafe", " isInValue() ");
@@ -1548,7 +1549,7 @@ public class SilkLexer extends Lexer {
                     }
                     break;
                 case 3 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:202:4: {...}? => PlainSafeOut
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:202:4: {...}? => PlainSafeOut
                     {
                     if ( !(( isOutValue() )) ) {
                         throw new FailedPredicateException(input, "PlainSafe", " isOutValue() ");
@@ -1570,11 +1571,11 @@ public class SilkLexer extends Lexer {
         try {
             int _type = PlainOneLine;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:206:13: ( PlainFirst ( ( WhiteSpace )* PlainSafe )* )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:206:15: PlainFirst ( ( WhiteSpace )* PlainSafe )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:13: ( PlainFirst ( ( WhiteSpace )* PlainSafe )* )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:15: PlainFirst ( ( WhiteSpace )* PlainSafe )*
             {
             mPlainFirst(); 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:206:26: ( ( WhiteSpace )* PlainSafe )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:26: ( ( WhiteSpace )* PlainSafe )*
             loop17:
             do {
                 int alt17=2;
@@ -1589,29 +1590,35 @@ public class SilkLexer extends Lexer {
                 else if ( (LA17_0=='*'||LA17_0==':'||LA17_0=='>'||LA17_0=='['||LA17_0==']'||LA17_0=='{'||LA17_0=='}') && ((( isInValue() )||( isOutValue() )))) {
                     alt17=1;
                 }
-                else if ( (LA17_0==',') && (( isOutValue() ))) {
+                else if ( ((LA17_0>='(' && LA17_0<=')')||LA17_0==',') && (( isOutValue() ))) {
                     alt17=1;
                 }
 
 
                 switch (alt17) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:206:27: ( WhiteSpace )* PlainSafe
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:27: ( WhiteSpace )* PlainSafe
             	    {
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:206:27: ( WhiteSpace )*
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:27: ( WhiteSpace )*
             	    loop16:
             	    do {
             	        int alt16=2;
             	        int LA16_0 = input.LA(1);
 
-            	        if ( (LA16_0=='\t'||LA16_0==' ') ) {
-            	            alt16=1;
+            	        if ( (LA16_0=='\t'||LA16_0==' ') && ((!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||( isOutValue() )||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||( isInValue() )||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||( isKey() )||!(((( isInValue() )||( isOutValue() )||( isKey() ))))||!(((( isInValue() )||( isOutValue() )||( isKey() ))))))) {
+            	            int LA16_1 = input.LA(2);
+
+            	            if ( (!(((( isInValue() )||( isOutValue() )||( isKey() ))))) ) {
+            	                alt16=1;
+            	            }
+
+
             	        }
 
 
             	        switch (alt16) {
             	    	case 1 :
-            	    	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:206:27: WhiteSpace
+            	    	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:27: WhiteSpace
             	    	    {
             	    	    mWhiteSpace(); 
 
@@ -1650,7 +1657,7 @@ public class SilkLexer extends Lexer {
         try {
             int _type = JSON;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:210:2: ({...}? => '{' | {...}? => '[' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:209:2: ({...}? => '{' | {...}? => '[' )
             int alt18=2;
             int LA18_0 = input.LA(1);
 
@@ -1668,7 +1675,7 @@ public class SilkLexer extends Lexer {
             }
             switch (alt18) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:210:4: {...}? => '{'
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:209:4: {...}? => '{'
                     {
                     if ( !(( isValue() )) ) {
                         throw new FailedPredicateException(input, "JSON", " isValue() ");
@@ -1688,7 +1695,7 @@ public class SilkLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:221:4: {...}? => '['
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:220:4: {...}? => '['
                     {
                     if ( !(( isValue() )) ) {
                         throw new FailedPredicateException(input, "JSON", " isValue() ");
@@ -1722,13 +1729,13 @@ public class SilkLexer extends Lexer {
         try {
             int _type = Separation;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:234:11: ({...}? ( WhiteSpace )+ )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:234:13: {...}? ( WhiteSpace )+
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:233:11: ({...}? ( WhiteSpace )+ )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:233:13: {...}? ( WhiteSpace )+
             {
-            if ( !(( currentState() != State.INIT )) ) {
-                throw new FailedPredicateException(input, "Separation", " currentState() != State.INIT ");
+            if ( !(( !isHead() )) ) {
+                throw new FailedPredicateException(input, "Separation", " !isHead() ");
             }
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:234:47: ( WhiteSpace )+
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:233:28: ( WhiteSpace )+
             int cnt19=0;
             loop19:
             do {
@@ -1742,7 +1749,7 @@ public class SilkLexer extends Lexer {
 
                 switch (alt19) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:234:47: WhiteSpace
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:233:28: WhiteSpace
             	    {
             	    mWhiteSpace(); 
 
@@ -1775,8 +1782,8 @@ public class SilkLexer extends Lexer {
         try {
             int _type = WhiteSpace;
             int _channel = DEFAULT_TOKEN_CHANNEL;
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:237:2: ( ( ' ' | '\\t' ) )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:237:4: ( ' ' | '\\t' )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:236:2: ( ( ' ' | '\\t' ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:236:4: ( ' ' | '\\t' )
             {
             if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
                 input.consume();
@@ -1799,173 +1806,173 @@ public class SilkLexer extends Lexer {
     // $ANTLR end "WhiteSpace"
 
     public void mTokens() throws RecognitionException {
-        // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:8: ( LineComment | Preamble | LineBreak | NodeIndent | FunctionIndent | BlankLine | DataLine | LParen | RParen | Comma | Colon | Seq | TabSeq | Star | At | Plus | LBracket | RBracket | Question | String | PlainOneLine | JSON | Separation | WhiteSpace )
+        // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:8: ( LineComment | Preamble | LineBreak | NodeIndent | FunctionIndent | BlankLine | DataLine | LParen | RParen | Comma | Colon | Seq | TabSeq | Star | At | Plus | LBracket | RBracket | Question | String | PlainOneLine | JSON | Separation | WhiteSpace )
         int alt20=24;
         alt20 = dfa20.predict(input);
         switch (alt20) {
             case 1 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:10: LineComment
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:10: LineComment
                 {
                 mLineComment(); 
 
                 }
                 break;
             case 2 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:22: Preamble
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:22: Preamble
                 {
                 mPreamble(); 
 
                 }
                 break;
             case 3 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:31: LineBreak
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:31: LineBreak
                 {
                 mLineBreak(); 
 
                 }
                 break;
             case 4 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:41: NodeIndent
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:41: NodeIndent
                 {
                 mNodeIndent(); 
 
                 }
                 break;
             case 5 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:52: FunctionIndent
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:52: FunctionIndent
                 {
                 mFunctionIndent(); 
 
                 }
                 break;
             case 6 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:67: BlankLine
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:67: BlankLine
                 {
                 mBlankLine(); 
 
                 }
                 break;
             case 7 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:77: DataLine
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:77: DataLine
                 {
                 mDataLine(); 
 
                 }
                 break;
             case 8 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:86: LParen
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:86: LParen
                 {
                 mLParen(); 
 
                 }
                 break;
             case 9 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:93: RParen
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:93: RParen
                 {
                 mRParen(); 
 
                 }
                 break;
             case 10 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:100: Comma
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:100: Comma
                 {
                 mComma(); 
 
                 }
                 break;
             case 11 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:106: Colon
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:106: Colon
                 {
                 mColon(); 
 
                 }
                 break;
             case 12 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:112: Seq
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:112: Seq
                 {
                 mSeq(); 
 
                 }
                 break;
             case 13 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:116: TabSeq
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:116: TabSeq
                 {
                 mTabSeq(); 
 
                 }
                 break;
             case 14 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:123: Star
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:123: Star
                 {
                 mStar(); 
 
                 }
                 break;
             case 15 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:128: At
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:128: At
                 {
                 mAt(); 
 
                 }
                 break;
             case 16 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:131: Plus
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:131: Plus
                 {
                 mPlus(); 
 
                 }
                 break;
             case 17 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:136: LBracket
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:136: LBracket
                 {
                 mLBracket(); 
 
                 }
                 break;
             case 18 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:145: RBracket
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:145: RBracket
                 {
                 mRBracket(); 
 
                 }
                 break;
             case 19 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:154: Question
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:154: Question
                 {
                 mQuestion(); 
 
                 }
                 break;
             case 20 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:163: String
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:163: String
                 {
                 mString(); 
 
                 }
                 break;
             case 21 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:170: PlainOneLine
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:170: PlainOneLine
                 {
                 mPlainOneLine(); 
 
                 }
                 break;
             case 22 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:183: JSON
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:183: JSON
                 {
                 mJSON(); 
 
                 }
                 break;
             case 23 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:188: Separation
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:188: Separation
                 {
                 mSeparation(); 
 
                 }
                 break;
             case 24 :
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:199: WhiteSpace
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:199: WhiteSpace
                 {
                 mWhiteSpace(); 
 
@@ -1979,37 +1986,37 @@ public class SilkLexer extends Lexer {
 
     protected DFA20 dfa20 = new DFA20(this);
     static final String DFA20_eotS =
-        "\3\uffff\1\31\1\32\1\34\1\uffff\1\40\1\34\1\41\1\42\1\43\1\45\1"+
+        "\3\uffff\1\31\1\32\1\33\1\uffff\1\40\1\33\1\41\1\42\1\43\1\45\1"+
         "\47\1\50\1\51\1\56\1\57\1\60\1\62\1\uffff\1\71\1\72\1\uffff\1\73"+
-        "\2\uffff\1\75\2\uffff\1\75\5\uffff\1\100\1\uffff\1\100\4\uffff\3"+
-        "\71\3\uffff\1\112\1\uffff\2\112\2\uffff\1\130\12\uffff\3\100\1\uffff"+
-        "\3\100\3\uffff\3\112\12\uffff\1\130\23\uffff";
+        "\4\uffff\1\75\1\uffff\1\75\4\uffff\1\100\1\uffff\1\100\3\uffff\4"+
+        "\71\3\uffff\1\112\1\uffff\2\112\2\uffff\1\130\11\uffff\10\100\2"+
+        "\uffff\4\112\12\uffff\1\130\23\uffff";
     static final String DFA20_eofS =
         "\155\uffff";
     static final String DFA20_minS =
-        "\1\0\2\uffff\1\12\2\0\1\uffff\20\0\1\uffff\5\0\1\uffff\1\0\1\uffff"+
-        "\1\0\3\uffff\1\0\1\uffff\1\0\3\uffff\4\0\1\uffff\1\0\1\uffff\1\0"+
+        "\1\0\2\uffff\1\12\2\0\1\uffff\20\0\1\uffff\4\0\1\uffff\1\0\1\uffff"+
+        "\2\0\3\uffff\1\0\1\uffff\1\0\3\uffff\4\0\1\uffff\1\0\1\uffff\1\0"+
         "\1\uffff\6\0\2\uffff\1\0\5\uffff\10\0\2\uffff\15\0\1\uffff\24\0";
     static final String DFA20_maxS =
         "\1\uffff\2\uffff\1\12\1\0\1\uffff\1\uffff\1\0\17\uffff\1\uffff"+
-        "\3\0\1\uffff\1\0\1\uffff\1\uffff\1\uffff\1\0\3\uffff\1\uffff\1\uffff"+
+        "\4\0\1\uffff\1\uffff\1\uffff\1\uffff\1\0\3\uffff\1\uffff\1\uffff"+
         "\1\uffff\3\uffff\4\uffff\1\uffff\1\0\1\uffff\1\uffff\1\uffff\6\uffff"+
         "\2\uffff\1\0\5\uffff\10\uffff\2\uffff\15\uffff\1\uffff\24\uffff";
     static final String DFA20_acceptS =
-        "\1\uffff\1\1\1\2\3\uffff\1\4\20\uffff\1\7\5\uffff\1\6\1\uffff\1"+
-        "\5\1\uffff\1\10\1\11\1\12\1\uffff\1\13\1\uffff\1\14\1\15\1\16\4"+
+        "\1\uffff\1\1\1\2\3\uffff\1\4\20\uffff\1\7\4\uffff\1\6\1\uffff\1"+
+        "\5\2\uffff\1\10\1\11\1\12\1\uffff\1\13\1\uffff\1\14\1\15\1\16\4"+
         "\uffff\1\20\1\uffff\1\22\1\uffff\1\23\6\uffff\1\25\1\26\1\uffff"+
         "\1\3\1\27\1\30\1\17\1\25\10\uffff\1\21\1\25\15\uffff\1\24\24\uffff";
     static final String DFA20_specialS =
-        "\1\111\4\uffff\1\61\2\uffff\1\100\1\16\1\107\1\25\1\43\1\112\1"+
-        "\31\1\3\1\65\1\52\1\50\1\74\1\13\1\35\1\62\2\uffff\1\77\1\76\1\2"+
-        "\1\47\1\uffff\1\71\1\uffff\1\27\3\uffff\1\103\1\uffff\1\30\3\uffff"+
-        "\1\55\1\44\1\6\1\36\1\uffff\1\63\1\uffff\1\5\1\uffff\1\51\1\22\1"+
-        "\70\1\40\1\23\1\46\2\uffff\1\101\5\uffff\1\56\1\45\1\7\1\37\1\54"+
-        "\1\116\1\60\1\34\2\uffff\1\72\1\102\1\75\1\33\1\41\1\53\1\113\1"+
-        "\24\1\0\1\10\1\21\1\115\1\4\1\uffff\1\17\1\57\1\106\1\32\1\66\1"+
-        "\20\1\1\1\104\1\110\1\114\1\73\1\11\1\14\1\26\1\15\1\64\1\42\1\67"+
-        "\1\105\1\12}>";
+        "\1\45\4\uffff\1\65\2\uffff\1\50\1\42\1\5\1\62\1\44\1\100\1\71\1"+
+        "\112\1\101\1\113\1\77\1\105\1\21\1\26\1\35\2\uffff\1\111\1\110\1"+
+        "\54\1\uffff\1\52\1\uffff\1\66\1\17\3\uffff\1\72\1\uffff\1\103\3"+
+        "\uffff\1\27\1\2\1\23\1\10\1\uffff\1\76\1\uffff\1\6\1\uffff\1\16"+
+        "\1\60\1\32\1\36\1\63\1\56\2\uffff\1\114\5\uffff\1\30\1\3\1\24\1"+
+        "\11\1\15\1\75\1\12\1\7\2\uffff\1\51\1\46\1\37\1\104\1\40\1\1\1\22"+
+        "\1\13\1\4\1\67\1\107\1\33\1\73\1\uffff\1\31\1\34\1\61\1\41\1\14"+
+        "\1\0\1\20\1\57\1\47\1\70\1\106\1\74\1\55\1\43\1\102\1\53\1\64\1"+
+        "\25\1\116\1\115}>";
     static final String[] DFA20_transitionS = {
             "\11\25\1\10\1\4\2\25\1\3\22\25\1\5\1\25\1\24\1\1\1\25\1\2\1"+
             "\25\1\27\1\11\1\12\1\17\1\20\1\13\1\6\14\25\1\14\3\25\1\15\1"+
@@ -2018,11 +2025,11 @@ public class SilkLexer extends Lexer {
             "",
             "\1\30",
             "\1\uffff",
-            "\11\27\1\36\1\35\2\27\1\35\22\27\1\33\2\27\1\uffff\1\27\1"+
-            "\uffff\7\27\1\6\22\27\1\37\uffbf\27",
+            "\11\27\1\37\1\34\2\27\1\34\22\27\1\35\2\27\1\uffff\1\27\1"+
+            "\uffff\7\27\1\6\22\27\1\36\uffbf\27",
             "",
             "\1\uffff",
-            "\11\27\1\36\1\35\2\27\1\35\22\27\1\36\2\27\1\uffff\1\27\1"+
+            "\11\27\1\37\1\34\2\27\1\34\22\27\1\37\2\27\1\uffff\1\27\1"+
             "\uffff\7\27\1\uffff\22\27\1\uffff\uffbf\27",
             "\0\27",
             "\0\27",
@@ -2031,19 +2038,19 @@ public class SilkLexer extends Lexer {
             "\uffa3\44",
             "\0\27",
             "\0\27",
-            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\27"+
+            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\55"+
             "\1\54\1\53\1\55\15\53\1\54\3\53\1\54\34\53\1\54\1\27\1\54\35"+
             "\53\1\54\1\53\1\54\uff82\53",
-            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\27"+
+            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\55"+
             "\1\54\1\53\1\55\15\53\1\54\3\53\1\54\34\53\1\54\1\27\1\54\35"+
             "\53\1\54\1\53\1\54\uff82\53",
             "\0\27",
             "\0\27",
             "\11\61\1\52\1\27\2\61\1\27\22\61\1\52\1\61\1\27\1\46\4\61"+
-            "\2\44\1\63\1\61\1\64\15\61\1\63\3\61\1\63\34\61\1\63\1\27\1"+
+            "\2\64\1\63\1\61\1\64\15\61\1\63\3\61\1\63\34\61\1\63\1\27\1"+
             "\63\35\61\1\63\1\61\1\63\uff82\61",
             "\12\65\1\27\2\65\1\27\24\65\1\67\1\70\70\65\1\66\uffa3\65",
-            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\27"+
+            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\55"+
             "\1\54\1\53\1\55\15\53\1\54\3\53\1\54\34\53\1\54\1\27\1\54\35"+
             "\53\1\54\1\53\1\54\uff82\53",
             "\0\27",
@@ -2051,51 +2058,51 @@ public class SilkLexer extends Lexer {
             "\1\uffff",
             "\1\uffff",
             "\1\uffff",
-            "\11\27\1\36\1\35\2\27\1\35\22\27\1\33\2\27\1\uffff\1\27\1"+
-            "\uffff\7\27\1\6\22\27\1\37\uffbf\27",
             "\1\uffff",
             "",
-            "\11\27\1\36\1\35\2\27\1\35\22\27\1\36\2\27\1\uffff\1\27\1"+
-            "\uffff\7\27\1\uffff\22\27\1\uffff\uffbf\27",
+            "\11\27\1\37\1\34\2\27\1\34\22\27\1\35\2\27\1\uffff\1\27\1"+
+            "\uffff\7\27\1\6\22\27\1\36\uffbf\27",
             "",
+            "\11\27\1\37\1\34\2\27\1\34\22\27\1\37\2\27\1\uffff\1\27\1"+
+            "\uffff\7\27\1\uffff\22\27\1\uffff\uffbf\27",
             "\1\uffff",
             "",
             "",
             "",
             "\11\102\1\101\1\27\2\102\1\27\22\102\1\101\1\102\2\27\4\102"+
-            "\2\27\1\103\1\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103"+
+            "\2\104\1\103\1\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103"+
             "\1\27\1\103\35\102\1\103\1\102\1\103\uff82\102",
             "",
             "\11\106\1\105\1\uffff\2\106\1\27\22\106\1\105\1\106\2\27\4"+
-            "\106\2\27\1\107\1\106\1\110\15\106\1\107\3\106\1\107\34\106"+
+            "\106\2\110\1\107\1\106\1\110\15\106\1\107\3\106\1\107\34\106"+
             "\1\107\1\27\1\107\35\106\1\107\1\106\1\107\uff82\106",
             "",
             "",
             "",
-            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\27"+
+            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\55"+
             "\1\54\1\53\1\55\15\53\1\54\3\53\1\54\34\53\1\54\1\27\1\54\35"+
             "\53\1\54\1\53\1\54\uff82\53",
-            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\27"+
+            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\55"+
             "\1\54\1\53\1\55\15\53\1\54\3\53\1\54\34\53\1\54\1\27\1\54\35"+
             "\53\1\54\1\53\1\54\uff82\53",
-            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\27"+
+            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\55"+
             "\1\54\1\53\1\55\15\53\1\54\3\53\1\54\34\53\1\54\1\27\1\54\35"+
             "\53\1\54\1\53\1\54\uff82\53",
-            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\27"+
+            "\11\53\1\52\1\27\2\53\1\27\22\53\1\52\1\53\2\27\4\53\2\55"+
             "\1\54\1\53\1\55\15\53\1\54\3\53\1\54\34\53\1\54\1\27\1\54\35"+
             "\53\1\54\1\53\1\54\uff82\53",
             "",
             "\1\uffff",
             "",
             "\11\114\1\113\1\27\2\114\1\27\22\114\1\113\1\114\2\27\4\114"+
-            "\2\27\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
+            "\2\116\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
             "\1\27\1\115\35\114\1\115\1\114\1\115\uff82\114",
             "",
             "\11\114\1\113\1\27\2\114\1\27\22\114\1\113\1\114\2\27\4\114"+
-            "\2\27\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
+            "\2\116\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
             "\1\27\1\115\35\114\1\115\1\114\1\115\uff82\114",
             "\11\114\1\113\1\27\2\114\1\27\22\114\1\113\1\114\2\27\4\114"+
-            "\2\27\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
+            "\2\116\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
             "\1\27\1\115\35\114\1\115\1\114\1\115\uff82\114",
             "\12\65\1\27\2\65\1\27\24\65\1\67\1\70\70\65\1\66\uffa3\65",
             "\42\27\1\117\14\27\1\121\54\27\1\120\5\27\1\122\3\27\1\123"+
@@ -2112,42 +2119,42 @@ public class SilkLexer extends Lexer {
             "",
             "",
             "\11\102\1\101\1\27\2\102\1\27\22\102\1\101\1\102\2\27\4\102"+
-            "\2\27\1\103\1\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103"+
+            "\2\104\1\103\1\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103"+
             "\1\27\1\103\35\102\1\103\1\102\1\103\uff82\102",
             "\11\102\1\101\1\27\2\102\1\27\22\102\1\101\1\102\2\27\4\102"+
-            "\2\27\1\103\1\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103"+
+            "\2\104\1\103\1\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103"+
             "\1\27\1\103\35\102\1\103\1\102\1\103\uff82\102",
             "\11\102\1\101\1\27\2\102\1\27\22\102\1\101\1\102\2\27\4\102"+
-            "\2\27\1\103\1\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103"+
+            "\2\104\1\103\1\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103"+
             "\1\27\1\103\35\102\1\103\1\102\1\103\uff82\102",
             "\11\102\1\101\1\27\2\102\1\27\22\102\1\101\1\102\2\27\4\102"+
-            "\2\27\1\103\1\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103"+
+            "\2\104\1\103\1\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103"+
             "\1\27\1\103\35\102\1\103\1\102\1\103\uff82\102",
             "\11\106\1\105\1\uffff\2\106\1\27\22\106\1\105\1\106\2\27\4"+
-            "\106\2\27\1\107\1\106\1\110\15\106\1\107\3\106\1\107\34\106"+
+            "\106\2\110\1\107\1\106\1\110\15\106\1\107\3\106\1\107\34\106"+
             "\1\107\1\27\1\107\35\106\1\107\1\106\1\107\uff82\106",
             "\11\106\1\105\1\uffff\2\106\1\27\22\106\1\105\1\106\2\27\4"+
-            "\106\2\27\1\107\1\106\1\110\15\106\1\107\3\106\1\107\34\106"+
+            "\106\2\110\1\107\1\106\1\110\15\106\1\107\3\106\1\107\34\106"+
             "\1\107\1\27\1\107\35\106\1\107\1\106\1\107\uff82\106",
             "\11\106\1\105\1\uffff\2\106\1\27\22\106\1\105\1\106\2\27\4"+
-            "\106\2\27\1\107\1\106\1\110\15\106\1\107\3\106\1\107\34\106"+
+            "\106\2\110\1\107\1\106\1\110\15\106\1\107\3\106\1\107\34\106"+
             "\1\107\1\27\1\107\35\106\1\107\1\106\1\107\uff82\106",
             "\11\106\1\105\1\uffff\2\106\1\27\22\106\1\105\1\106\2\27\4"+
-            "\106\2\27\1\107\1\106\1\110\15\106\1\107\3\106\1\107\34\106"+
+            "\106\2\110\1\107\1\106\1\110\15\106\1\107\3\106\1\107\34\106"+
             "\1\107\1\27\1\107\35\106\1\107\1\106\1\107\uff82\106",
             "",
             "",
             "\11\114\1\113\1\27\2\114\1\27\22\114\1\113\1\114\2\27\4\114"+
-            "\2\27\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
+            "\2\116\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
             "\1\27\1\115\35\114\1\115\1\114\1\115\uff82\114",
             "\11\114\1\113\1\27\2\114\1\27\22\114\1\113\1\114\2\27\4\114"+
-            "\2\27\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
+            "\2\116\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
             "\1\27\1\115\35\114\1\115\1\114\1\115\uff82\114",
             "\11\114\1\113\1\27\2\114\1\27\22\114\1\113\1\114\2\27\4\114"+
-            "\2\27\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
+            "\2\116\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
             "\1\27\1\115\35\114\1\115\1\114\1\115\uff82\114",
             "\11\114\1\113\1\27\2\114\1\27\22\114\1\113\1\114\2\27\4\114"+
-            "\2\27\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
+            "\2\116\1\115\1\114\1\116\15\114\1\115\3\114\1\115\34\114\1\115"+
             "\1\27\1\115\35\114\1\115\1\114\1\115\uff82\114",
             "\12\65\1\27\2\65\1\27\24\65\1\67\1\70\70\65\1\66\uffa3\65",
             "\12\65\1\27\2\65\1\27\24\65\1\67\1\70\70\65\1\66\uffa3\65",
@@ -2230,697 +2237,752 @@ public class SilkLexer extends Lexer {
         	int _s = s;
             switch ( s ) {
                     case 0 : 
-                        int LA20_83 = input.LA(1);
+                        int LA20_94 = input.LA(1);
 
                          
-                        int index20_83 = input.index();
+                        int index20_94 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_83=='\"') ) {s = 55;}
-
-                        else if ( (LA20_83=='#') ) {s = 56;}
+                        if ( (LA20_94=='\"') ) {s = 89;}
 
-                        else if ( (LA20_83=='\\') ) {s = 54;}
+                        else if ( ((LA20_94>='\u0000' && LA20_94<='\t')||(LA20_94>='\u000B' && LA20_94<='\f')||(LA20_94>='\u000E' && LA20_94<='!')||(LA20_94>='#' && LA20_94<='[')||(LA20_94>=']' && LA20_94<='\uFFFF')) ) {s = 90;}
 
-                        else if ( (LA20_83=='\n'||LA20_83=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_94=='\\') ) {s = 91;}
 
-                        else if ( ((LA20_83>='\u0000' && LA20_83<='\t')||(LA20_83>='\u000B' && LA20_83<='\f')||(LA20_83>='\u000E' && LA20_83<='!')||(LA20_83>='$' && LA20_83<='[')||(LA20_83>=']' && LA20_83<='\uFFFF')) ) {s = 53;}
+                        else if ( (LA20_94=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_83);
+                        input.seek(index20_94);
                         if ( s>=0 ) return s;
                         break;
                     case 1 : 
-                        int LA20_95 = input.LA(1);
+                        int LA20_80 = input.LA(1);
 
                          
-                        int index20_95 = input.index();
+                        int index20_80 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_95=='\"') ) {s = 89;}
+                        if ( (LA20_80=='\"') ) {s = 55;}
 
-                        else if ( ((LA20_95>='\u0000' && LA20_95<='\t')||(LA20_95>='\u000B' && LA20_95<='\f')||(LA20_95>='\u000E' && LA20_95<='!')||(LA20_95>='#' && LA20_95<='[')||(LA20_95>=']' && LA20_95<='\uFFFF')) ) {s = 90;}
+                        else if ( (LA20_80=='#') ) {s = 56;}
 
-                        else if ( (LA20_95=='\\') ) {s = 91;}
+                        else if ( (LA20_80=='\\') ) {s = 54;}
 
-                        else if ( (LA20_95=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_80=='\n'||LA20_80=='\r') && (( isHead() ))) {s = 23;}
+
+                        else if ( ((LA20_80>='\u0000' && LA20_80<='\t')||(LA20_80>='\u000B' && LA20_80<='\f')||(LA20_80>='\u000E' && LA20_80<='!')||(LA20_80>='$' && LA20_80<='[')||(LA20_80>=']' && LA20_80<='\uFFFF')) ) {s = 53;}
 
                          
-                        input.seek(index20_95);
+                        input.seek(index20_80);
                         if ( s>=0 ) return s;
                         break;
                     case 2 : 
-                        int LA20_27 = input.LA(1);
+                        int LA20_43 = input.LA(1);
 
                          
-                        int index20_27 = input.index();
+                        int index20_43 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_27=='-') ) {s = 6;}
-
-                        else if ( (LA20_27==' ') ) {s = 27;}
+                        if ( (LA20_43=='\t'||LA20_43==' ') ) {s = 42;}
 
-                        else if ( (LA20_27=='\n'||LA20_27=='\r') ) {s = 29;}
+                        else if ( ((LA20_43>='\u0000' && LA20_43<='\b')||(LA20_43>='\u000B' && LA20_43<='\f')||(LA20_43>='\u000E' && LA20_43<='\u001F')||LA20_43=='!'||(LA20_43>='$' && LA20_43<='\'')||LA20_43=='+'||(LA20_43>='-' && LA20_43<='9')||(LA20_43>=';' && LA20_43<='=')||(LA20_43>='?' && LA20_43<='Z')||(LA20_43>='^' && LA20_43<='z')||LA20_43=='|'||(LA20_43>='~' && LA20_43<='\uFFFF')) ) {s = 43;}
 
-                        else if ( (LA20_27=='\t') ) {s = 30;}
+                        else if ( (LA20_43=='*'||LA20_43==':'||LA20_43=='>'||LA20_43=='['||LA20_43==']'||LA20_43=='{'||LA20_43=='}') ) {s = 44;}
 
-                        else if ( (LA20_27=='@') && (( isHead() ))) {s = 31;}
+                        else if ( ((LA20_43>='(' && LA20_43<=')')||LA20_43==',') ) {s = 45;}
 
-                        else if ( ((LA20_27>='\u0000' && LA20_27<='\b')||(LA20_27>='\u000B' && LA20_27<='\f')||(LA20_27>='\u000E' && LA20_27<='\u001F')||(LA20_27>='!' && LA20_27<='\"')||LA20_27=='$'||(LA20_27>='&' && LA20_27<=',')||(LA20_27>='.' && LA20_27<='?')||(LA20_27>='A' && LA20_27<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_43=='\n'||LA20_43=='\r'||(LA20_43>='\"' && LA20_43<='#')||LA20_43=='\\') && (( isHead() ))) {s = 23;}
 
-                        else s = 61;
+                        else s = 57;
 
                          
-                        input.seek(index20_27);
+                        input.seek(index20_43);
                         if ( s>=0 ) return s;
                         break;
                     case 3 : 
-                        int LA20_15 = input.LA(1);
+                        int LA20_66 = input.LA(1);
 
                          
-                        int index20_15 = input.index();
+                        int index20_66 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_15=='\t'||LA20_15==' ') ) {s = 42;}
+                        if ( (LA20_66=='\t'||LA20_66==' ') && ((( isValue() )||( isHead() )))) {s = 65;}
 
-                        else if ( ((LA20_15>='\u0000' && LA20_15<='\b')||(LA20_15>='\u000B' && LA20_15<='\f')||(LA20_15>='\u000E' && LA20_15<='\u001F')||LA20_15=='!'||(LA20_15>='$' && LA20_15<='\'')||LA20_15=='+'||(LA20_15>='-' && LA20_15<='9')||(LA20_15>=';' && LA20_15<='=')||(LA20_15>='?' && LA20_15<='Z')||(LA20_15>='^' && LA20_15<='z')||LA20_15=='|'||(LA20_15>='~' && LA20_15<='\uFFFF')) ) {s = 43;}
+                        else if ( ((LA20_66>='\u0000' && LA20_66<='\b')||(LA20_66>='\u000B' && LA20_66<='\f')||(LA20_66>='\u000E' && LA20_66<='\u001F')||LA20_66=='!'||(LA20_66>='$' && LA20_66<='\'')||LA20_66=='+'||(LA20_66>='-' && LA20_66<='9')||(LA20_66>=';' && LA20_66<='=')||(LA20_66>='?' && LA20_66<='Z')||(LA20_66>='^' && LA20_66<='z')||LA20_66=='|'||(LA20_66>='~' && LA20_66<='\uFFFF')) && ((( isValue() )||( isHead() )))) {s = 66;}
 
-                        else if ( (LA20_15=='*'||LA20_15==':'||LA20_15=='>'||LA20_15=='['||LA20_15==']'||LA20_15=='{'||LA20_15=='}') ) {s = 44;}
+                        else if ( (LA20_66=='*'||LA20_66==':'||LA20_66=='>'||LA20_66=='['||LA20_66==']'||LA20_66=='{'||LA20_66=='}') && ((( isValue() )||( isHead() )))) {s = 67;}
 
-                        else if ( (LA20_15==',') ) {s = 45;}
+                        else if ( ((LA20_66>='(' && LA20_66<=')')||LA20_66==',') && ((( isValue() )||( isHead() )))) {s = 68;}
 
-                        else if ( (LA20_15=='\n'||LA20_15=='\r'||(LA20_15>='\"' && LA20_15<='#')||(LA20_15>='(' && LA20_15<=')')||LA20_15=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_66=='\n'||LA20_66=='\r'||(LA20_66>='\"' && LA20_66<='#')||LA20_66=='\\') && (( isHead() ))) {s = 23;}
 
-                        else s = 41;
+                        else s = 64;
 
                          
-                        input.seek(index20_15);
+                        input.seek(index20_66);
                         if ( s>=0 ) return s;
                         break;
                     case 4 : 
-                        int LA20_87 = input.LA(1);
+                        int LA20_83 = input.LA(1);
 
                          
-                        int index20_87 = input.index();
+                        int index20_83 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_87>='0' && LA20_87<='9')||(LA20_87>='A' && LA20_87<='F')||(LA20_87>='a' && LA20_87<='f')) ) {s = 92;}
+                        if ( (LA20_83=='\"') ) {s = 55;}
 
-                        else if ( ((LA20_87>='\u0000' && LA20_87<='/')||(LA20_87>=':' && LA20_87<='@')||(LA20_87>='G' && LA20_87<='`')||(LA20_87>='g' && LA20_87<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_83=='#') ) {s = 56;}
+
+                        else if ( (LA20_83=='\\') ) {s = 54;}
+
+                        else if ( (LA20_83=='\n'||LA20_83=='\r') && (( isHead() ))) {s = 23;}
+
+                        else if ( ((LA20_83>='\u0000' && LA20_83<='\t')||(LA20_83>='\u000B' && LA20_83<='\f')||(LA20_83>='\u000E' && LA20_83<='!')||(LA20_83>='$' && LA20_83<='[')||(LA20_83>=']' && LA20_83<='\uFFFF')) ) {s = 53;}
 
                          
-                        input.seek(index20_87);
+                        input.seek(index20_83);
                         if ( s>=0 ) return s;
                         break;
                     case 5 : 
-                        int LA20_49 = input.LA(1);
+                        int LA20_10 = input.LA(1);
 
                          
-                        int index20_49 = input.index();
+                        int index20_10 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_49=='\t'||LA20_49==' ') ) {s = 75;}
-
-                        else if ( ((LA20_49>='\u0000' && LA20_49<='\b')||(LA20_49>='\u000B' && LA20_49<='\f')||(LA20_49>='\u000E' && LA20_49<='\u001F')||LA20_49=='!'||(LA20_49>='$' && LA20_49<='\'')||LA20_49=='+'||(LA20_49>='-' && LA20_49<='9')||(LA20_49>=';' && LA20_49<='=')||(LA20_49>='?' && LA20_49<='Z')||(LA20_49>='^' && LA20_49<='z')||LA20_49=='|'||(LA20_49>='~' && LA20_49<='\uFFFF')) ) {s = 76;}
-
-                        else if ( (LA20_49=='*'||LA20_49==':'||LA20_49=='>'||LA20_49=='['||LA20_49==']'||LA20_49=='{'||LA20_49=='}') ) {s = 77;}
-
-                        else if ( (LA20_49==',') ) {s = 78;}
-
-                        else if ( (LA20_49=='\n'||LA20_49=='\r'||(LA20_49>='\"' && LA20_49<='#')||(LA20_49>='(' && LA20_49<=')')||LA20_49=='\\') && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_10>='\u0000' && LA20_10<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else s = 74;
+                        else s = 34;
 
                          
-                        input.seek(index20_49);
+                        input.seek(index20_10);
                         if ( s>=0 ) return s;
                         break;
                     case 6 : 
-                        int LA20_44 = input.LA(1);
+                        int LA20_49 = input.LA(1);
 
                          
-                        int index20_44 = input.index();
+                        int index20_49 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_44=='\t'||LA20_44==' ') ) {s = 42;}
+                        if ( (LA20_49=='\t'||LA20_49==' ') ) {s = 75;}
 
-                        else if ( ((LA20_44>='\u0000' && LA20_44<='\b')||(LA20_44>='\u000B' && LA20_44<='\f')||(LA20_44>='\u000E' && LA20_44<='\u001F')||LA20_44=='!'||(LA20_44>='$' && LA20_44<='\'')||LA20_44=='+'||(LA20_44>='-' && LA20_44<='9')||(LA20_44>=';' && LA20_44<='=')||(LA20_44>='?' && LA20_44<='Z')||(LA20_44>='^' && LA20_44<='z')||LA20_44=='|'||(LA20_44>='~' && LA20_44<='\uFFFF')) ) {s = 43;}
+                        else if ( ((LA20_49>='\u0000' && LA20_49<='\b')||(LA20_49>='\u000B' && LA20_49<='\f')||(LA20_49>='\u000E' && LA20_49<='\u001F')||LA20_49=='!'||(LA20_49>='$' && LA20_49<='\'')||LA20_49=='+'||(LA20_49>='-' && LA20_49<='9')||(LA20_49>=';' && LA20_49<='=')||(LA20_49>='?' && LA20_49<='Z')||(LA20_49>='^' && LA20_49<='z')||LA20_49=='|'||(LA20_49>='~' && LA20_49<='\uFFFF')) ) {s = 76;}
 
-                        else if ( (LA20_44=='*'||LA20_44==':'||LA20_44=='>'||LA20_44=='['||LA20_44==']'||LA20_44=='{'||LA20_44=='}') ) {s = 44;}
+                        else if ( (LA20_49=='*'||LA20_49==':'||LA20_49=='>'||LA20_49=='['||LA20_49==']'||LA20_49=='{'||LA20_49=='}') ) {s = 77;}
 
-                        else if ( (LA20_44==',') ) {s = 45;}
+                        else if ( ((LA20_49>='(' && LA20_49<=')')||LA20_49==',') ) {s = 78;}
 
-                        else if ( (LA20_44=='\n'||LA20_44=='\r'||(LA20_44>='\"' && LA20_44<='#')||(LA20_44>='(' && LA20_44<=')')||LA20_44=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_49=='\n'||LA20_49=='\r'||(LA20_49>='\"' && LA20_49<='#')||LA20_49=='\\') && (( isHead() ))) {s = 23;}
 
-                        else s = 57;
+                        else s = 74;
 
                          
-                        input.seek(index20_44);
+                        input.seek(index20_49);
                         if ( s>=0 ) return s;
                         break;
                     case 7 : 
-                        int LA20_67 = input.LA(1);
+                        int LA20_72 = input.LA(1);
 
                          
-                        int index20_67 = input.index();
+                        int index20_72 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_67=='\t'||LA20_67==' ') && ((( isHead() )||( isValue() )))) {s = 65;}
+                        if ( (LA20_72=='\t'||LA20_72==' ') && ((( isHead() )||( isValue() )))) {s = 69;}
 
-                        else if ( ((LA20_67>='\u0000' && LA20_67<='\b')||(LA20_67>='\u000B' && LA20_67<='\f')||(LA20_67>='\u000E' && LA20_67<='\u001F')||LA20_67=='!'||(LA20_67>='$' && LA20_67<='\'')||LA20_67=='+'||(LA20_67>='-' && LA20_67<='9')||(LA20_67>=';' && LA20_67<='=')||(LA20_67>='?' && LA20_67<='Z')||(LA20_67>='^' && LA20_67<='z')||LA20_67=='|'||(LA20_67>='~' && LA20_67<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 66;}
+                        else if ( ((LA20_72>='\u0000' && LA20_72<='\b')||(LA20_72>='\u000B' && LA20_72<='\f')||(LA20_72>='\u000E' && LA20_72<='\u001F')||LA20_72=='!'||(LA20_72>='$' && LA20_72<='\'')||LA20_72=='+'||(LA20_72>='-' && LA20_72<='9')||(LA20_72>=';' && LA20_72<='=')||(LA20_72>='?' && LA20_72<='Z')||(LA20_72>='^' && LA20_72<='z')||LA20_72=='|'||(LA20_72>='~' && LA20_72<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 70;}
 
-                        else if ( (LA20_67=='*'||LA20_67==':'||LA20_67=='>'||LA20_67=='['||LA20_67==']'||LA20_67=='{'||LA20_67=='}') && ((( isValue() )||( isHead() )))) {s = 67;}
+                        else if ( (LA20_72=='*'||LA20_72==':'||LA20_72=='>'||LA20_72=='['||LA20_72==']'||LA20_72=='{'||LA20_72=='}') && ((( isHead() )||( isValue() )))) {s = 71;}
 
-                        else if ( (LA20_67==',') && ((( isHead() )||( isValue() )))) {s = 68;}
+                        else if ( ((LA20_72>='(' && LA20_72<=')')||LA20_72==',') && ((( isHead() )||( isValue() )))) {s = 72;}
 
-                        else if ( (LA20_67=='\n'||LA20_67=='\r'||(LA20_67>='\"' && LA20_67<='#')||(LA20_67>='(' && LA20_67<=')')||LA20_67=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_72=='\r'||(LA20_72>='\"' && LA20_72<='#')||LA20_72=='\\') && (( isHead() ))) {s = 23;}
 
                         else s = 64;
 
                          
-                        input.seek(index20_67);
+                        input.seek(index20_72);
                         if ( s>=0 ) return s;
                         break;
                     case 8 : 
-                        int LA20_84 = input.LA(1);
+                        int LA20_45 = input.LA(1);
 
                          
-                        int index20_84 = input.index();
+                        int index20_45 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_84=='\"') ) {s = 55;}
+                        if ( (LA20_45=='\t'||LA20_45==' ') ) {s = 42;}
 
-                        else if ( (LA20_84=='#') ) {s = 56;}
+                        else if ( ((LA20_45>='\u0000' && LA20_45<='\b')||(LA20_45>='\u000B' && LA20_45<='\f')||(LA20_45>='\u000E' && LA20_45<='\u001F')||LA20_45=='!'||(LA20_45>='$' && LA20_45<='\'')||LA20_45=='+'||(LA20_45>='-' && LA20_45<='9')||(LA20_45>=';' && LA20_45<='=')||(LA20_45>='?' && LA20_45<='Z')||(LA20_45>='^' && LA20_45<='z')||LA20_45=='|'||(LA20_45>='~' && LA20_45<='\uFFFF')) ) {s = 43;}
 
-                        else if ( (LA20_84=='\\') ) {s = 54;}
+                        else if ( (LA20_45=='*'||LA20_45==':'||LA20_45=='>'||LA20_45=='['||LA20_45==']'||LA20_45=='{'||LA20_45=='}') ) {s = 44;}
 
-                        else if ( (LA20_84=='\n'||LA20_84=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_45>='(' && LA20_45<=')')||LA20_45==',') ) {s = 45;}
 
-                        else if ( ((LA20_84>='\u0000' && LA20_84<='\t')||(LA20_84>='\u000B' && LA20_84<='\f')||(LA20_84>='\u000E' && LA20_84<='!')||(LA20_84>='$' && LA20_84<='[')||(LA20_84>=']' && LA20_84<='\uFFFF')) ) {s = 53;}
+                        else if ( (LA20_45=='\n'||LA20_45=='\r'||(LA20_45>='\"' && LA20_45<='#')||LA20_45=='\\') && (( isHead() ))) {s = 23;}
+
+                        else s = 57;
 
                          
-                        input.seek(index20_84);
+                        input.seek(index20_45);
                         if ( s>=0 ) return s;
                         break;
                     case 9 : 
-                        int LA20_100 = input.LA(1);
+                        int LA20_68 = input.LA(1);
 
                          
-                        int index20_100 = input.index();
+                        int index20_68 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_100=='\"') ) {s = 89;}
+                        if ( (LA20_68=='\t'||LA20_68==' ') && ((( isValue() )||( isHead() )))) {s = 65;}
 
-                        else if ( ((LA20_100>='\u0000' && LA20_100<='\t')||(LA20_100>='\u000B' && LA20_100<='\f')||(LA20_100>='\u000E' && LA20_100<='!')||(LA20_100>='#' && LA20_100<='[')||(LA20_100>=']' && LA20_100<='\uFFFF')) ) {s = 90;}
+                        else if ( ((LA20_68>='\u0000' && LA20_68<='\b')||(LA20_68>='\u000B' && LA20_68<='\f')||(LA20_68>='\u000E' && LA20_68<='\u001F')||LA20_68=='!'||(LA20_68>='$' && LA20_68<='\'')||LA20_68=='+'||(LA20_68>='-' && LA20_68<='9')||(LA20_68>=';' && LA20_68<='=')||(LA20_68>='?' && LA20_68<='Z')||(LA20_68>='^' && LA20_68<='z')||LA20_68=='|'||(LA20_68>='~' && LA20_68<='\uFFFF')) && ((( isValue() )||( isHead() )))) {s = 66;}
 
-                        else if ( (LA20_100=='\\') ) {s = 91;}
+                        else if ( (LA20_68=='*'||LA20_68==':'||LA20_68=='>'||LA20_68=='['||LA20_68==']'||LA20_68=='{'||LA20_68=='}') && ((( isValue() )||( isHead() )))) {s = 67;}
 
-                        else if ( (LA20_100=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_68>='(' && LA20_68<=')')||LA20_68==',') && ((( isValue() )||( isHead() )))) {s = 68;}
+
+                        else if ( (LA20_68=='\n'||LA20_68=='\r'||(LA20_68>='\"' && LA20_68<='#')||LA20_68=='\\') && (( isHead() ))) {s = 23;}
+
+                        else s = 64;
 
                          
-                        input.seek(index20_100);
+                        input.seek(index20_68);
                         if ( s>=0 ) return s;
                         break;
                     case 10 : 
-                        int LA20_108 = input.LA(1);
+                        int LA20_71 = input.LA(1);
 
                          
-                        int index20_108 = input.index();
+                        int index20_71 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_108=='\r') && (( isHead() ))) {s = 23;}
+                        if ( (LA20_71=='\t'||LA20_71==' ') && ((( isHead() )||( isValue() )))) {s = 69;}
 
-                        else if ( (LA20_108=='\"') ) {s = 89;}
+                        else if ( ((LA20_71>='\u0000' && LA20_71<='\b')||(LA20_71>='\u000B' && LA20_71<='\f')||(LA20_71>='\u000E' && LA20_71<='\u001F')||LA20_71=='!'||(LA20_71>='$' && LA20_71<='\'')||LA20_71=='+'||(LA20_71>='-' && LA20_71<='9')||(LA20_71>=';' && LA20_71<='=')||(LA20_71>='?' && LA20_71<='Z')||(LA20_71>='^' && LA20_71<='z')||LA20_71=='|'||(LA20_71>='~' && LA20_71<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 70;}
 
-                        else if ( ((LA20_108>='\u0000' && LA20_108<='\t')||(LA20_108>='\u000B' && LA20_108<='\f')||(LA20_108>='\u000E' && LA20_108<='!')||(LA20_108>='#' && LA20_108<='[')||(LA20_108>=']' && LA20_108<='\uFFFF')) ) {s = 90;}
+                        else if ( (LA20_71=='*'||LA20_71==':'||LA20_71=='>'||LA20_71=='['||LA20_71==']'||LA20_71=='{'||LA20_71=='}') && ((( isHead() )||( isValue() )))) {s = 71;}
 
-                        else if ( (LA20_108=='\\') ) {s = 91;}
+                        else if ( ((LA20_71>='(' && LA20_71<=')')||LA20_71==',') && ((( isHead() )||( isValue() )))) {s = 72;}
+
+                        else if ( (LA20_71=='\r'||(LA20_71>='\"' && LA20_71<='#')||LA20_71=='\\') && (( isHead() ))) {s = 23;}
+
+                        else s = 64;
 
                          
-                        input.seek(index20_108);
+                        input.seek(index20_71);
                         if ( s>=0 ) return s;
                         break;
                     case 11 : 
-                        int LA20_20 = input.LA(1);
+                        int LA20_82 = input.LA(1);
 
                          
-                        int index20_20 = input.index();
+                        int index20_82 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_20>='\u0000' && LA20_20<='\t')||(LA20_20>='\u000B' && LA20_20<='\f')||(LA20_20>='\u000E' && LA20_20<='!')||(LA20_20>='$' && LA20_20<='[')||(LA20_20>=']' && LA20_20<='\uFFFF')) ) {s = 53;}
+                        if ( (LA20_82=='\"') ) {s = 55;}
 
-                        else if ( (LA20_20=='\\') ) {s = 54;}
+                        else if ( (LA20_82=='#') ) {s = 56;}
 
-                        else if ( (LA20_20=='\"') ) {s = 55;}
+                        else if ( (LA20_82=='\\') ) {s = 54;}
 
-                        else if ( (LA20_20=='#') ) {s = 56;}
+                        else if ( (LA20_82=='\n'||LA20_82=='\r') && (( isHead() ))) {s = 23;}
 
-                        else if ( (LA20_20=='\n'||LA20_20=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_82>='\u0000' && LA20_82<='\t')||(LA20_82>='\u000B' && LA20_82<='\f')||(LA20_82>='\u000E' && LA20_82<='!')||(LA20_82>='$' && LA20_82<='[')||(LA20_82>=']' && LA20_82<='\uFFFF')) ) {s = 53;}
 
                          
-                        input.seek(index20_20);
+                        input.seek(index20_82);
                         if ( s>=0 ) return s;
                         break;
                     case 12 : 
-                        int LA20_101 = input.LA(1);
+                        int LA20_93 = input.LA(1);
 
                          
-                        int index20_101 = input.index();
+                        int index20_93 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_101>='0' && LA20_101<='9')||(LA20_101>='A' && LA20_101<='F')||(LA20_101>='a' && LA20_101<='f')) ) {s = 103;}
+                        if ( (LA20_93=='\"') ) {s = 89;}
 
-                        else if ( ((LA20_101>='\u0000' && LA20_101<='\t')||(LA20_101>='\u000B' && LA20_101<='/')||(LA20_101>=':' && LA20_101<='@')||(LA20_101>='G' && LA20_101<='`')||(LA20_101>='g' && LA20_101<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_93>='\u0000' && LA20_93<='\t')||(LA20_93>='\u000B' && LA20_93<='\f')||(LA20_93>='\u000E' && LA20_93<='!')||(LA20_93>='#' && LA20_93<='[')||(LA20_93>=']' && LA20_93<='\uFFFF')) ) {s = 90;}
+
+                        else if ( (LA20_93=='\\') ) {s = 91;}
+
+                        else if ( (LA20_93=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_101);
+                        input.seek(index20_93);
                         if ( s>=0 ) return s;
                         break;
                     case 13 : 
-                        int LA20_103 = input.LA(1);
+                        int LA20_69 = input.LA(1);
 
                          
-                        int index20_103 = input.index();
+                        int index20_69 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_103>='0' && LA20_103<='9')||(LA20_103>='A' && LA20_103<='F')||(LA20_103>='a' && LA20_103<='f')) ) {s = 105;}
+                        if ( (LA20_69=='\t'||LA20_69==' ') && ((( isHead() )||( isValue() )))) {s = 69;}
 
-                        else if ( ((LA20_103>='\u0000' && LA20_103<='\t')||(LA20_103>='\u000B' && LA20_103<='/')||(LA20_103>=':' && LA20_103<='@')||(LA20_103>='G' && LA20_103<='`')||(LA20_103>='g' && LA20_103<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_69>='\u0000' && LA20_69<='\b')||(LA20_69>='\u000B' && LA20_69<='\f')||(LA20_69>='\u000E' && LA20_69<='\u001F')||LA20_69=='!'||(LA20_69>='$' && LA20_69<='\'')||LA20_69=='+'||(LA20_69>='-' && LA20_69<='9')||(LA20_69>=';' && LA20_69<='=')||(LA20_69>='?' && LA20_69<='Z')||(LA20_69>='^' && LA20_69<='z')||LA20_69=='|'||(LA20_69>='~' && LA20_69<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 70;}
+
+                        else if ( (LA20_69=='*'||LA20_69==':'||LA20_69=='>'||LA20_69=='['||LA20_69==']'||LA20_69=='{'||LA20_69=='}') && ((( isHead() )||( isValue() )))) {s = 71;}
+
+                        else if ( ((LA20_69>='(' && LA20_69<=')')||LA20_69==',') && ((( isHead() )||( isValue() )))) {s = 72;}
+
+                        else if ( (LA20_69=='\r'||(LA20_69>='\"' && LA20_69<='#')||LA20_69=='\\') && (( isHead() ))) {s = 23;}
+
+                        else s = 64;
 
                          
-                        input.seek(index20_103);
+                        input.seek(index20_69);
                         if ( s>=0 ) return s;
                         break;
                     case 14 : 
-                        int LA20_9 = input.LA(1);
+                        int LA20_51 = input.LA(1);
 
                          
-                        int index20_9 = input.index();
+                        int index20_51 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_9>='\u0000' && LA20_9<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( (LA20_51=='\t'||LA20_51==' ') ) {s = 75;}
 
-                        else s = 33;
+                        else if ( ((LA20_51>='\u0000' && LA20_51<='\b')||(LA20_51>='\u000B' && LA20_51<='\f')||(LA20_51>='\u000E' && LA20_51<='\u001F')||LA20_51=='!'||(LA20_51>='$' && LA20_51<='\'')||LA20_51=='+'||(LA20_51>='-' && LA20_51<='9')||(LA20_51>=';' && LA20_51<='=')||(LA20_51>='?' && LA20_51<='Z')||(LA20_51>='^' && LA20_51<='z')||LA20_51=='|'||(LA20_51>='~' && LA20_51<='\uFFFF')) ) {s = 76;}
+
+                        else if ( (LA20_51=='*'||LA20_51==':'||LA20_51=='>'||LA20_51=='['||LA20_51==']'||LA20_51=='{'||LA20_51=='}') ) {s = 77;}
+
+                        else if ( ((LA20_51>='(' && LA20_51<=')')||LA20_51==',') ) {s = 78;}
+
+                        else if ( (LA20_51=='\n'||LA20_51=='\r'||(LA20_51>='\"' && LA20_51<='#')||LA20_51=='\\') && (( isHead() ))) {s = 23;}
+
+                        else s = 74;
 
                          
-                        input.seek(index20_9);
+                        input.seek(index20_51);
                         if ( s>=0 ) return s;
                         break;
                     case 15 : 
-                        int LA20_89 = input.LA(1);
+                        int LA20_32 = input.LA(1);
 
                          
-                        int index20_89 = input.index();
+                        int index20_32 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_89>='\u0000' && LA20_89<='\t')||(LA20_89>='\u000B' && LA20_89<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( (( isHead() )) ) {s = 30;}
 
-                        else s = 88;
+                        else if ( (true) ) {s = 63;}
 
                          
-                        input.seek(index20_89);
+                        input.seek(index20_32);
                         if ( s>=0 ) return s;
                         break;
                     case 16 : 
-                        int LA20_94 = input.LA(1);
+                        int LA20_95 = input.LA(1);
 
                          
-                        int index20_94 = input.index();
+                        int index20_95 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_94=='\r') && (( isHead() ))) {s = 23;}
+                        if ( (LA20_95=='\"') ) {s = 89;}
 
-                        else if ( (LA20_94=='\"') ) {s = 89;}
+                        else if ( ((LA20_95>='\u0000' && LA20_95<='\t')||(LA20_95>='\u000B' && LA20_95<='\f')||(LA20_95>='\u000E' && LA20_95<='!')||(LA20_95>='#' && LA20_95<='[')||(LA20_95>=']' && LA20_95<='\uFFFF')) ) {s = 90;}
 
-                        else if ( ((LA20_94>='\u0000' && LA20_94<='\t')||(LA20_94>='\u000B' && LA20_94<='\f')||(LA20_94>='\u000E' && LA20_94<='!')||(LA20_94>='#' && LA20_94<='[')||(LA20_94>=']' && LA20_94<='\uFFFF')) ) {s = 90;}
+                        else if ( (LA20_95=='\\') ) {s = 91;}
 
-                        else if ( (LA20_94=='\\') ) {s = 91;}
+                        else if ( (LA20_95=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_94);
+                        input.seek(index20_95);
                         if ( s>=0 ) return s;
                         break;
                     case 17 : 
-                        int LA20_85 = input.LA(1);
+                        int LA20_20 = input.LA(1);
 
                          
-                        int index20_85 = input.index();
+                        int index20_20 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_85=='\n'||LA20_85=='\r') && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_20>='\u0000' && LA20_20<='\t')||(LA20_20>='\u000B' && LA20_20<='\f')||(LA20_20>='\u000E' && LA20_20<='!')||(LA20_20>='$' && LA20_20<='[')||(LA20_20>=']' && LA20_20<='\uFFFF')) ) {s = 53;}
 
-                        else if ( (LA20_85=='#') ) {s = 56;}
+                        else if ( (LA20_20=='\\') ) {s = 54;}
 
-                        else if ( (LA20_85=='\"') ) {s = 55;}
+                        else if ( (LA20_20=='\"') ) {s = 55;}
 
-                        else if ( ((LA20_85>='\u0000' && LA20_85<='\t')||(LA20_85>='\u000B' && LA20_85<='\f')||(LA20_85>='\u000E' && LA20_85<='!')||(LA20_85>='$' && LA20_85<='[')||(LA20_85>=']' && LA20_85<='\uFFFF')) ) {s = 53;}
+                        else if ( (LA20_20=='#') ) {s = 56;}
 
-                        else if ( (LA20_85=='\\') ) {s = 54;}
+                        else if ( (LA20_20=='\n'||LA20_20=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_85);
+                        input.seek(index20_20);
                         if ( s>=0 ) return s;
                         break;
                     case 18 : 
-                        int LA20_52 = input.LA(1);
+                        int LA20_81 = input.LA(1);
 
                          
-                        int index20_52 = input.index();
+                        int index20_81 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_52=='\n'||LA20_52=='\r'||(LA20_52>='\"' && LA20_52<='#')||(LA20_52>='(' && LA20_52<=')')||LA20_52=='\\') && (( isHead() ))) {s = 23;}
+                        if ( (LA20_81=='\"') ) {s = 55;}
 
-                        else if ( (LA20_52=='\t'||LA20_52==' ') ) {s = 75;}
+                        else if ( (LA20_81=='#') ) {s = 56;}
 
-                        else if ( ((LA20_52>='\u0000' && LA20_52<='\b')||(LA20_52>='\u000B' && LA20_52<='\f')||(LA20_52>='\u000E' && LA20_52<='\u001F')||LA20_52=='!'||(LA20_52>='$' && LA20_52<='\'')||LA20_52=='+'||(LA20_52>='-' && LA20_52<='9')||(LA20_52>=';' && LA20_52<='=')||(LA20_52>='?' && LA20_52<='Z')||(LA20_52>='^' && LA20_52<='z')||LA20_52=='|'||(LA20_52>='~' && LA20_52<='\uFFFF')) ) {s = 76;}
+                        else if ( (LA20_81=='\\') ) {s = 54;}
 
-                        else if ( (LA20_52=='*'||LA20_52==':'||LA20_52=='>'||LA20_52=='['||LA20_52==']'||LA20_52=='{'||LA20_52=='}') ) {s = 77;}
+                        else if ( (LA20_81=='\n'||LA20_81=='\r') && (( isHead() ))) {s = 23;}
 
-                        else if ( (LA20_52==',') ) {s = 78;}
-
-                        else s = 74;
+                        else if ( ((LA20_81>='\u0000' && LA20_81<='\t')||(LA20_81>='\u000B' && LA20_81<='\f')||(LA20_81>='\u000E' && LA20_81<='!')||(LA20_81>='$' && LA20_81<='[')||(LA20_81>=']' && LA20_81<='\uFFFF')) ) {s = 53;}
 
                          
-                        input.seek(index20_52);
+                        input.seek(index20_81);
                         if ( s>=0 ) return s;
                         break;
                     case 19 : 
-                        int LA20_55 = input.LA(1);
+                        int LA20_44 = input.LA(1);
 
                          
-                        int index20_55 = input.index();
+                        int index20_44 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_55>='\u0000' && LA20_55<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( (LA20_44=='\t'||LA20_44==' ') ) {s = 42;}
 
-                        else s = 88;
+                        else if ( ((LA20_44>='\u0000' && LA20_44<='\b')||(LA20_44>='\u000B' && LA20_44<='\f')||(LA20_44>='\u000E' && LA20_44<='\u001F')||LA20_44=='!'||(LA20_44>='$' && LA20_44<='\'')||LA20_44=='+'||(LA20_44>='-' && LA20_44<='9')||(LA20_44>=';' && LA20_44<='=')||(LA20_44>='?' && LA20_44<='Z')||(LA20_44>='^' && LA20_44<='z')||LA20_44=='|'||(LA20_44>='~' && LA20_44<='\uFFFF')) ) {s = 43;}
+
+                        else if ( (LA20_44=='*'||LA20_44==':'||LA20_44=='>'||LA20_44=='['||LA20_44==']'||LA20_44=='{'||LA20_44=='}') ) {s = 44;}
+
+                        else if ( ((LA20_44>='(' && LA20_44<=')')||LA20_44==',') ) {s = 45;}
+
+                        else if ( (LA20_44=='\n'||LA20_44=='\r'||(LA20_44>='\"' && LA20_44<='#')||LA20_44=='\\') && (( isHead() ))) {s = 23;}
+
+                        else s = 57;
 
                          
-                        input.seek(index20_55);
+                        input.seek(index20_44);
                         if ( s>=0 ) return s;
                         break;
                     case 20 : 
-                        int LA20_82 = input.LA(1);
+                        int LA20_67 = input.LA(1);
 
                          
-                        int index20_82 = input.index();
+                        int index20_67 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_82=='\"') ) {s = 55;}
+                        if ( (LA20_67=='\t'||LA20_67==' ') && ((( isValue() )||( isHead() )))) {s = 65;}
 
-                        else if ( (LA20_82=='#') ) {s = 56;}
+                        else if ( ((LA20_67>='\u0000' && LA20_67<='\b')||(LA20_67>='\u000B' && LA20_67<='\f')||(LA20_67>='\u000E' && LA20_67<='\u001F')||LA20_67=='!'||(LA20_67>='$' && LA20_67<='\'')||LA20_67=='+'||(LA20_67>='-' && LA20_67<='9')||(LA20_67>=';' && LA20_67<='=')||(LA20_67>='?' && LA20_67<='Z')||(LA20_67>='^' && LA20_67<='z')||LA20_67=='|'||(LA20_67>='~' && LA20_67<='\uFFFF')) && ((( isValue() )||( isHead() )))) {s = 66;}
 
-                        else if ( (LA20_82=='\\') ) {s = 54;}
+                        else if ( (LA20_67=='*'||LA20_67==':'||LA20_67=='>'||LA20_67=='['||LA20_67==']'||LA20_67=='{'||LA20_67=='}') && ((( isValue() )||( isHead() )))) {s = 67;}
 
-                        else if ( (LA20_82=='\n'||LA20_82=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_67>='(' && LA20_67<=')')||LA20_67==',') && ((( isValue() )||( isHead() )))) {s = 68;}
 
-                        else if ( ((LA20_82>='\u0000' && LA20_82<='\t')||(LA20_82>='\u000B' && LA20_82<='\f')||(LA20_82>='\u000E' && LA20_82<='!')||(LA20_82>='$' && LA20_82<='[')||(LA20_82>=']' && LA20_82<='\uFFFF')) ) {s = 53;}
+                        else if ( (LA20_67=='\n'||LA20_67=='\r'||(LA20_67>='\"' && LA20_67<='#')||LA20_67=='\\') && (( isHead() ))) {s = 23;}
+
+                        else s = 64;
 
                          
-                        input.seek(index20_82);
+                        input.seek(index20_67);
                         if ( s>=0 ) return s;
                         break;
                     case 21 : 
-                        int LA20_11 = input.LA(1);
+                        int LA20_106 = input.LA(1);
 
                          
-                        int index20_11 = input.index();
+                        int index20_106 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_11>='\u0000' && LA20_11<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( (LA20_106=='\n'||LA20_106=='\r') && (( isHead() ))) {s = 23;}
 
-                        else s = 35;
+                        else if ( (LA20_106=='#') ) {s = 56;}
+
+                        else if ( (LA20_106=='\"') ) {s = 55;}
+
+                        else if ( ((LA20_106>='\u0000' && LA20_106<='\t')||(LA20_106>='\u000B' && LA20_106<='\f')||(LA20_106>='\u000E' && LA20_106<='!')||(LA20_106>='$' && LA20_106<='[')||(LA20_106>=']' && LA20_106<='\uFFFF')) ) {s = 53;}
+
+                        else if ( (LA20_106=='\\') ) {s = 54;}
 
                          
-                        input.seek(index20_11);
+                        input.seek(index20_106);
                         if ( s>=0 ) return s;
                         break;
                     case 22 : 
-                        int LA20_102 = input.LA(1);
+                        int LA20_21 = input.LA(1);
 
                          
-                        int index20_102 = input.index();
+                        int index20_21 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_102>='0' && LA20_102<='9')||(LA20_102>='A' && LA20_102<='F')||(LA20_102>='a' && LA20_102<='f')) ) {s = 104;}
+                        if ( (LA20_21=='\t'||LA20_21==' ') ) {s = 42;}
 
-                        else if ( ((LA20_102>='\u0000' && LA20_102<='/')||(LA20_102>=':' && LA20_102<='@')||(LA20_102>='G' && LA20_102<='`')||(LA20_102>='g' && LA20_102<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_21=='\n'||LA20_21=='\r'||(LA20_21>='\"' && LA20_21<='#')||LA20_21=='\\') && (( isHead() ))) {s = 23;}
+
+                        else if ( ((LA20_21>='\u0000' && LA20_21<='\b')||(LA20_21>='\u000B' && LA20_21<='\f')||(LA20_21>='\u000E' && LA20_21<='\u001F')||LA20_21=='!'||(LA20_21>='$' && LA20_21<='\'')||LA20_21=='+'||(LA20_21>='-' && LA20_21<='9')||(LA20_21>=';' && LA20_21<='=')||(LA20_21>='?' && LA20_21<='Z')||(LA20_21>='^' && LA20_21<='z')||LA20_21=='|'||(LA20_21>='~' && LA20_21<='\uFFFF')) ) {s = 43;}
+
+                        else if ( (LA20_21=='*'||LA20_21==':'||LA20_21=='>'||LA20_21=='['||LA20_21==']'||LA20_21=='{'||LA20_21=='}') ) {s = 44;}
+
+                        else if ( ((LA20_21>='(' && LA20_21<=')')||LA20_21==',') ) {s = 45;}
+
+                        else s = 57;
 
                          
-                        input.seek(index20_102);
+                        input.seek(index20_21);
                         if ( s>=0 ) return s;
                         break;
                     case 23 : 
-                        int LA20_32 = input.LA(1);
+                        int LA20_42 = input.LA(1);
 
                          
-                        int index20_32 = input.index();
+                        int index20_42 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (( isHead() )) ) {s = 31;}
+                        if ( (LA20_42=='\t'||LA20_42==' ') ) {s = 42;}
 
-                        else if ( (true) ) {s = 63;}
+                        else if ( ((LA20_42>='\u0000' && LA20_42<='\b')||(LA20_42>='\u000B' && LA20_42<='\f')||(LA20_42>='\u000E' && LA20_42<='\u001F')||LA20_42=='!'||(LA20_42>='$' && LA20_42<='\'')||LA20_42=='+'||(LA20_42>='-' && LA20_42<='9')||(LA20_42>=';' && LA20_42<='=')||(LA20_42>='?' && LA20_42<='Z')||(LA20_42>='^' && LA20_42<='z')||LA20_42=='|'||(LA20_42>='~' && LA20_42<='\uFFFF')) ) {s = 43;}
+
+                        else if ( (LA20_42=='*'||LA20_42==':'||LA20_42=='>'||LA20_42=='['||LA20_42==']'||LA20_42=='{'||LA20_42=='}') ) {s = 44;}
+
+                        else if ( ((LA20_42>='(' && LA20_42<=')')||LA20_42==',') ) {s = 45;}
+
+                        else if ( (LA20_42=='\n'||LA20_42=='\r'||(LA20_42>='\"' && LA20_42<='#')||LA20_42=='\\') && (( isHead() ))) {s = 23;}
+
+                        else s = 57;
 
                          
-                        input.seek(index20_32);
+                        input.seek(index20_42);
                         if ( s>=0 ) return s;
                         break;
                     case 24 : 
-                        int LA20_38 = input.LA(1);
+                        int LA20_65 = input.LA(1);
 
                          
-                        int index20_38 = input.index();
+                        int index20_65 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_38=='\t'||LA20_38==' ') && ((( isHead() )||( isValue() )))) {s = 69;}
+                        if ( (LA20_65=='\t'||LA20_65==' ') && ((( isValue() )||( isHead() )))) {s = 65;}
 
-                        else if ( ((LA20_38>='\u0000' && LA20_38<='\b')||(LA20_38>='\u000B' && LA20_38<='\f')||(LA20_38>='\u000E' && LA20_38<='\u001F')||LA20_38=='!'||(LA20_38>='$' && LA20_38<='\'')||LA20_38=='+'||(LA20_38>='-' && LA20_38<='9')||(LA20_38>=';' && LA20_38<='=')||(LA20_38>='?' && LA20_38<='Z')||(LA20_38>='^' && LA20_38<='z')||LA20_38=='|'||(LA20_38>='~' && LA20_38<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 70;}
+                        else if ( ((LA20_65>='\u0000' && LA20_65<='\b')||(LA20_65>='\u000B' && LA20_65<='\f')||(LA20_65>='\u000E' && LA20_65<='\u001F')||LA20_65=='!'||(LA20_65>='$' && LA20_65<='\'')||LA20_65=='+'||(LA20_65>='-' && LA20_65<='9')||(LA20_65>=';' && LA20_65<='=')||(LA20_65>='?' && LA20_65<='Z')||(LA20_65>='^' && LA20_65<='z')||LA20_65=='|'||(LA20_65>='~' && LA20_65<='\uFFFF')) && ((( isValue() )||( isHead() )))) {s = 66;}
 
-                        else if ( (LA20_38=='*'||LA20_38==':'||LA20_38=='>'||LA20_38=='['||LA20_38==']'||LA20_38=='{'||LA20_38=='}') && ((( isHead() )||( isValue() )))) {s = 71;}
+                        else if ( (LA20_65=='*'||LA20_65==':'||LA20_65=='>'||LA20_65=='['||LA20_65==']'||LA20_65=='{'||LA20_65=='}') && ((( isValue() )||( isHead() )))) {s = 67;}
 
-                        else if ( (LA20_38==',') && ((( isHead() )||( isValue() )))) {s = 72;}
+                        else if ( ((LA20_65>='(' && LA20_65<=')')||LA20_65==',') && ((( isValue() )||( isHead() )))) {s = 68;}
 
-                        else if ( (LA20_38=='\r'||(LA20_38>='\"' && LA20_38<='#')||(LA20_38>='(' && LA20_38<=')')||LA20_38=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_65=='\n'||LA20_65=='\r'||(LA20_65>='\"' && LA20_65<='#')||LA20_65=='\\') && (( isHead() ))) {s = 23;}
 
                         else s = 64;
 
                          
-                        input.seek(index20_38);
+                        input.seek(index20_65);
                         if ( s>=0 ) return s;
                         break;
                     case 25 : 
-                        int LA20_14 = input.LA(1);
+                        int LA20_89 = input.LA(1);
 
                          
-                        int index20_14 = input.index();
+                        int index20_89 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_14>='\u0000' && LA20_14<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_89>='\u0000' && LA20_89<='\t')||(LA20_89>='\u000B' && LA20_89<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else s = 40;
+                        else s = 88;
 
                          
-                        input.seek(index20_14);
+                        input.seek(index20_89);
                         if ( s>=0 ) return s;
                         break;
                     case 26 : 
-                        int LA20_92 = input.LA(1);
+                        int LA20_53 = input.LA(1);
 
                          
-                        int index20_92 = input.index();
+                        int index20_53 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_92>='0' && LA20_92<='9')||(LA20_92>='A' && LA20_92<='F')||(LA20_92>='a' && LA20_92<='f')) ) {s = 102;}
+                        if ( (LA20_53=='\"') ) {s = 55;}
 
-                        else if ( ((LA20_92>='\u0000' && LA20_92<='/')||(LA20_92>=':' && LA20_92<='@')||(LA20_92>='G' && LA20_92<='`')||(LA20_92>='g' && LA20_92<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_53=='#') ) {s = 56;}
+
+                        else if ( (LA20_53=='\\') ) {s = 54;}
+
+                        else if ( (LA20_53=='\n'||LA20_53=='\r') && (( isHead() ))) {s = 23;}
+
+                        else if ( ((LA20_53>='\u0000' && LA20_53<='\t')||(LA20_53>='\u000B' && LA20_53<='\f')||(LA20_53>='\u000E' && LA20_53<='!')||(LA20_53>='$' && LA20_53<='[')||(LA20_53>=']' && LA20_53<='\uFFFF')) ) {s = 53;}
 
                          
-                        input.seek(index20_92);
+                        input.seek(index20_53);
                         if ( s>=0 ) return s;
                         break;
                     case 27 : 
-                        int LA20_78 = input.LA(1);
+                        int LA20_86 = input.LA(1);
 
                          
-                        int index20_78 = input.index();
+                        int index20_86 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_78=='\n'||LA20_78=='\r'||(LA20_78>='\"' && LA20_78<='#')||(LA20_78>='(' && LA20_78<=')')||LA20_78=='\\') && (( isHead() ))) {s = 23;}
-
-                        else if ( (LA20_78=='\t'||LA20_78==' ') ) {s = 75;}
+                        if ( (LA20_86=='\"') ) {s = 55;}
 
-                        else if ( ((LA20_78>='\u0000' && LA20_78<='\b')||(LA20_78>='\u000B' && LA20_78<='\f')||(LA20_78>='\u000E' && LA20_78<='\u001F')||LA20_78=='!'||(LA20_78>='$' && LA20_78<='\'')||LA20_78=='+'||(LA20_78>='-' && LA20_78<='9')||(LA20_78>=';' && LA20_78<='=')||(LA20_78>='?' && LA20_78<='Z')||(LA20_78>='^' && LA20_78<='z')||LA20_78=='|'||(LA20_78>='~' && LA20_78<='\uFFFF')) ) {s = 76;}
+                        else if ( (LA20_86=='#') ) {s = 56;}
 
-                        else if ( (LA20_78=='*'||LA20_78==':'||LA20_78=='>'||LA20_78=='['||LA20_78==']'||LA20_78=='{'||LA20_78=='}') ) {s = 77;}
+                        else if ( (LA20_86=='\\') ) {s = 54;}
 
-                        else if ( (LA20_78==',') ) {s = 78;}
+                        else if ( (LA20_86=='\n'||LA20_86=='\r') && (( isHead() ))) {s = 23;}
 
-                        else s = 74;
+                        else if ( ((LA20_86>='\u0000' && LA20_86<='\t')||(LA20_86>='\u000B' && LA20_86<='\f')||(LA20_86>='\u000E' && LA20_86<='!')||(LA20_86>='$' && LA20_86<='[')||(LA20_86>=']' && LA20_86<='\uFFFF')) ) {s = 53;}
 
                          
-                        input.seek(index20_78);
+                        input.seek(index20_86);
                         if ( s>=0 ) return s;
                         break;
                     case 28 : 
-                        int LA20_72 = input.LA(1);
+                        int LA20_90 = input.LA(1);
 
                          
-                        int index20_72 = input.index();
+                        int index20_90 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_72=='\r'||(LA20_72>='\"' && LA20_72<='#')||(LA20_72>='(' && LA20_72<=')')||LA20_72=='\\') && (( isHead() ))) {s = 23;}
-
-                        else if ( (LA20_72=='\t'||LA20_72==' ') && ((( isHead() )||( isValue() )))) {s = 69;}
-
-                        else if ( ((LA20_72>='\u0000' && LA20_72<='\b')||(LA20_72>='\u000B' && LA20_72<='\f')||(LA20_72>='\u000E' && LA20_72<='\u001F')||LA20_72=='!'||(LA20_72>='$' && LA20_72<='\'')||LA20_72=='+'||(LA20_72>='-' && LA20_72<='9')||(LA20_72>=';' && LA20_72<='=')||(LA20_72>='?' && LA20_72<='Z')||(LA20_72>='^' && LA20_72<='z')||LA20_72=='|'||(LA20_72>='~' && LA20_72<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 70;}
+                        if ( (LA20_90=='\"') ) {s = 89;}
 
-                        else if ( (LA20_72=='*'||LA20_72==':'||LA20_72=='>'||LA20_72=='['||LA20_72==']'||LA20_72=='{'||LA20_72=='}') && ((( isHead() )||( isValue() )))) {s = 71;}
+                        else if ( ((LA20_90>='\u0000' && LA20_90<='\t')||(LA20_90>='\u000B' && LA20_90<='\f')||(LA20_90>='\u000E' && LA20_90<='!')||(LA20_90>='#' && LA20_90<='[')||(LA20_90>=']' && LA20_90<='\uFFFF')) ) {s = 90;}
 
-                        else if ( (LA20_72==',') && ((( isHead() )||( isValue() )))) {s = 72;}
+                        else if ( (LA20_90=='\\') ) {s = 91;}
 
-                        else s = 64;
+                        else if ( (LA20_90=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_72);
+                        input.seek(index20_90);
                         if ( s>=0 ) return s;
                         break;
                     case 29 : 
-                        int LA20_21 = input.LA(1);
+                        int LA20_22 = input.LA(1);
 
                          
-                        int index20_21 = input.index();
+                        int index20_22 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_21=='\t'||LA20_21==' ') ) {s = 42;}
-
-                        else if ( ((LA20_21>='\u0000' && LA20_21<='\b')||(LA20_21>='\u000B' && LA20_21<='\f')||(LA20_21>='\u000E' && LA20_21<='\u001F')||LA20_21=='!'||(LA20_21>='$' && LA20_21<='\'')||LA20_21=='+'||(LA20_21>='-' && LA20_21<='9')||(LA20_21>=';' && LA20_21<='=')||(LA20_21>='?' && LA20_21<='Z')||(LA20_21>='^' && LA20_21<='z')||LA20_21=='|'||(LA20_21>='~' && LA20_21<='\uFFFF')) ) {s = 43;}
-
-                        else if ( (LA20_21=='*'||LA20_21==':'||LA20_21=='>'||LA20_21=='['||LA20_21==']'||LA20_21=='{'||LA20_21=='}') ) {s = 44;}
-
-                        else if ( (LA20_21==',') ) {s = 45;}
-
-                        else if ( (LA20_21=='\n'||LA20_21=='\r'||(LA20_21>='\"' && LA20_21<='#')||(LA20_21>='(' && LA20_21<=')')||LA20_21=='\\') && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_22>='\u0000' && LA20_22<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else s = 57;
+                        else s = 58;
 
                          
-                        input.seek(index20_21);
+                        input.seek(index20_22);
                         if ( s>=0 ) return s;
                         break;
                     case 30 : 
-                        int LA20_45 = input.LA(1);
+                        int LA20_54 = input.LA(1);
 
                          
-                        int index20_45 = input.index();
+                        int index20_54 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_45=='\n'||LA20_45=='\r'||(LA20_45>='\"' && LA20_45<='#')||(LA20_45>='(' && LA20_45<=')')||LA20_45=='\\') && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_54>='\u0000' && LA20_54<='!')||(LA20_54>='#' && LA20_54<='.')||(LA20_54>='0' && LA20_54<='[')||(LA20_54>=']' && LA20_54<='a')||(LA20_54>='c' && LA20_54<='e')||(LA20_54>='g' && LA20_54<='m')||(LA20_54>='o' && LA20_54<='q')||LA20_54=='s'||(LA20_54>='v' && LA20_54<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else if ( (LA20_45=='\t'||LA20_45==' ') ) {s = 42;}
+                        else if ( (LA20_54=='\"') ) {s = 79;}
 
-                        else if ( ((LA20_45>='\u0000' && LA20_45<='\b')||(LA20_45>='\u000B' && LA20_45<='\f')||(LA20_45>='\u000E' && LA20_45<='\u001F')||LA20_45=='!'||(LA20_45>='$' && LA20_45<='\'')||LA20_45=='+'||(LA20_45>='-' && LA20_45<='9')||(LA20_45>=';' && LA20_45<='=')||(LA20_45>='?' && LA20_45<='Z')||(LA20_45>='^' && LA20_45<='z')||LA20_45=='|'||(LA20_45>='~' && LA20_45<='\uFFFF')) ) {s = 43;}
+                        else if ( (LA20_54=='\\') ) {s = 80;}
 
-                        else if ( (LA20_45=='*'||LA20_45==':'||LA20_45=='>'||LA20_45=='['||LA20_45==']'||LA20_45=='{'||LA20_45=='}') ) {s = 44;}
+                        else if ( (LA20_54=='/') ) {s = 81;}
 
-                        else if ( (LA20_45==',') ) {s = 45;}
+                        else if ( (LA20_54=='b') ) {s = 82;}
 
-                        else s = 57;
+                        else if ( (LA20_54=='f') ) {s = 83;}
+
+                        else if ( (LA20_54=='n') ) {s = 84;}
+
+                        else if ( (LA20_54=='r') ) {s = 85;}
+
+                        else if ( (LA20_54=='t') ) {s = 86;}
+
+                        else if ( (LA20_54=='u') ) {s = 87;}
 
                          
-                        input.seek(index20_45);
+                        input.seek(index20_54);
                         if ( s>=0 ) return s;
                         break;
                     case 31 : 
-                        int LA20_68 = input.LA(1);
+                        int LA20_77 = input.LA(1);
 
                          
-                        int index20_68 = input.index();
+                        int index20_77 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_68=='\n'||LA20_68=='\r'||(LA20_68>='\"' && LA20_68<='#')||(LA20_68>='(' && LA20_68<=')')||LA20_68=='\\') && (( isHead() ))) {s = 23;}
+                        if ( (LA20_77=='\t'||LA20_77==' ') ) {s = 75;}
 
-                        else if ( (LA20_68=='\t'||LA20_68==' ') && ((( isHead() )||( isValue() )))) {s = 65;}
+                        else if ( ((LA20_77>='\u0000' && LA20_77<='\b')||(LA20_77>='\u000B' && LA20_77<='\f')||(LA20_77>='\u000E' && LA20_77<='\u001F')||LA20_77=='!'||(LA20_77>='$' && LA20_77<='\'')||LA20_77=='+'||(LA20_77>='-' && LA20_77<='9')||(LA20_77>=';' && LA20_77<='=')||(LA20_77>='?' && LA20_77<='Z')||(LA20_77>='^' && LA20_77<='z')||LA20_77=='|'||(LA20_77>='~' && LA20_77<='\uFFFF')) ) {s = 76;}
 
-                        else if ( ((LA20_68>='\u0000' && LA20_68<='\b')||(LA20_68>='\u000B' && LA20_68<='\f')||(LA20_68>='\u000E' && LA20_68<='\u001F')||LA20_68=='!'||(LA20_68>='$' && LA20_68<='\'')||LA20_68=='+'||(LA20_68>='-' && LA20_68<='9')||(LA20_68>=';' && LA20_68<='=')||(LA20_68>='?' && LA20_68<='Z')||(LA20_68>='^' && LA20_68<='z')||LA20_68=='|'||(LA20_68>='~' && LA20_68<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 66;}
+                        else if ( (LA20_77=='*'||LA20_77==':'||LA20_77=='>'||LA20_77=='['||LA20_77==']'||LA20_77=='{'||LA20_77=='}') ) {s = 77;}
 
-                        else if ( (LA20_68=='*'||LA20_68==':'||LA20_68=='>'||LA20_68=='['||LA20_68==']'||LA20_68=='{'||LA20_68=='}') && ((( isValue() )||( isHead() )))) {s = 67;}
+                        else if ( ((LA20_77>='(' && LA20_77<=')')||LA20_77==',') ) {s = 78;}
 
-                        else if ( (LA20_68==',') && ((( isHead() )||( isValue() )))) {s = 68;}
+                        else if ( (LA20_77=='\n'||LA20_77=='\r'||(LA20_77>='\"' && LA20_77<='#')||LA20_77=='\\') && (( isHead() ))) {s = 23;}
 
-                        else s = 64;
+                        else s = 74;
 
                          
-                        input.seek(index20_68);
+                        input.seek(index20_77);
                         if ( s>=0 ) return s;
                         break;
                     case 32 : 
-                        int LA20_54 = input.LA(1);
+                        int LA20_79 = input.LA(1);
 
                          
-                        int index20_54 = input.index();
+                        int index20_79 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_54=='\"') ) {s = 79;}
-
-                        else if ( (LA20_54=='\\') ) {s = 80;}
-
-                        else if ( (LA20_54=='/') ) {s = 81;}
-
-                        else if ( (LA20_54=='b') ) {s = 82;}
-
-                        else if ( (LA20_54=='f') ) {s = 83;}
-
-                        else if ( (LA20_54=='n') ) {s = 84;}
+                        if ( (LA20_79=='\n'||LA20_79=='\r') && (( isHead() ))) {s = 23;}
 
-                        else if ( (LA20_54=='r') ) {s = 85;}
+                        else if ( (LA20_79=='#') ) {s = 56;}
 
-                        else if ( (LA20_54=='t') ) {s = 86;}
+                        else if ( (LA20_79=='\"') ) {s = 55;}
 
-                        else if ( (LA20_54=='u') ) {s = 87;}
+                        else if ( ((LA20_79>='\u0000' && LA20_79<='\t')||(LA20_79>='\u000B' && LA20_79<='\f')||(LA20_79>='\u000E' && LA20_79<='!')||(LA20_79>='$' && LA20_79<='[')||(LA20_79>=']' && LA20_79<='\uFFFF')) ) {s = 53;}
 
-                        else if ( ((LA20_54>='\u0000' && LA20_54<='!')||(LA20_54>='#' && LA20_54<='.')||(LA20_54>='0' && LA20_54<='[')||(LA20_54>=']' && LA20_54<='a')||(LA20_54>='c' && LA20_54<='e')||(LA20_54>='g' && LA20_54<='m')||(LA20_54>='o' && LA20_54<='q')||LA20_54=='s'||(LA20_54>='v' && LA20_54<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_79=='\\') ) {s = 54;}
 
                          
-                        input.seek(index20_54);
+                        input.seek(index20_79);
                         if ( s>=0 ) return s;
                         break;
                     case 33 : 
-                        int LA20_79 = input.LA(1);
+                        int LA20_92 = input.LA(1);
 
                          
-                        int index20_79 = input.index();
+                        int index20_92 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_79=='\n'||LA20_79=='\r') && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_92>='0' && LA20_92<='9')||(LA20_92>='A' && LA20_92<='F')||(LA20_92>='a' && LA20_92<='f')) ) {s = 102;}
 
-                        else if ( (LA20_79=='#') ) {s = 56;}
+                        else if ( ((LA20_92>='\u0000' && LA20_92<='/')||(LA20_92>=':' && LA20_92<='@')||(LA20_92>='G' && LA20_92<='`')||(LA20_92>='g' && LA20_92<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else if ( (LA20_79=='\"') ) {s = 55;}
+                         
+                        input.seek(index20_92);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 34 : 
+                        int LA20_9 = input.LA(1);
 
-                        else if ( ((LA20_79>='\u0000' && LA20_79<='\t')||(LA20_79>='\u000B' && LA20_79<='\f')||(LA20_79>='\u000E' && LA20_79<='!')||(LA20_79>='$' && LA20_79<='[')||(LA20_79>=']' && LA20_79<='\uFFFF')) ) {s = 53;}
+                         
+                        int index20_9 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( ((LA20_9>='\u0000' && LA20_9<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else if ( (LA20_79=='\\') ) {s = 54;}
+                        else s = 33;
 
                          
-                        input.seek(index20_79);
+                        input.seek(index20_9);
                         if ( s>=0 ) return s;
                         break;
-                    case 34 : 
-                        int LA20_105 = input.LA(1);
+                    case 35 : 
+                        int LA20_102 = input.LA(1);
 
                          
-                        int index20_105 = input.index();
+                        int index20_102 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_105>='0' && LA20_105<='9')||(LA20_105>='A' && LA20_105<='F')||(LA20_105>='a' && LA20_105<='f')) ) {s = 107;}
+                        if ( ((LA20_102>='\u0000' && LA20_102<='/')||(LA20_102>=':' && LA20_102<='@')||(LA20_102>='G' && LA20_102<='`')||(LA20_102>='g' && LA20_102<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else if ( ((LA20_105>='\u0000' && LA20_105<='\t')||(LA20_105>='\u000B' && LA20_105<='/')||(LA20_105>=':' && LA20_105<='@')||(LA20_105>='G' && LA20_105<='`')||(LA20_105>='g' && LA20_105<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_102>='0' && LA20_102<='9')||(LA20_102>='A' && LA20_102<='F')||(LA20_102>='a' && LA20_102<='f')) ) {s = 104;}
 
                          
-                        input.seek(index20_105);
+                        input.seek(index20_102);
                         if ( s>=0 ) return s;
                         break;
-                    case 35 : 
+                    case 36 : 
                         int LA20_12 = input.LA(1);
 
                          
@@ -2939,891 +3001,842 @@ public class SilkLexer extends Lexer {
                         input.seek(index20_12);
                         if ( s>=0 ) return s;
                         break;
-                    case 36 : 
-                        int LA20_43 = input.LA(1);
+                    case 37 : 
+                        int LA20_0 = input.LA(1);
 
                          
-                        int index20_43 = input.index();
+                        int index20_0 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_43=='\t'||LA20_43==' ') ) {s = 42;}
+                        if ( (LA20_0=='#') ) {s = 1;}
 
-                        else if ( ((LA20_43>='\u0000' && LA20_43<='\b')||(LA20_43>='\u000B' && LA20_43<='\f')||(LA20_43>='\u000E' && LA20_43<='\u001F')||LA20_43=='!'||(LA20_43>='$' && LA20_43<='\'')||LA20_43=='+'||(LA20_43>='-' && LA20_43<='9')||(LA20_43>=';' && LA20_43<='=')||(LA20_43>='?' && LA20_43<='Z')||(LA20_43>='^' && LA20_43<='z')||LA20_43=='|'||(LA20_43>='~' && LA20_43<='\uFFFF')) ) {s = 43;}
+                        else if ( (LA20_0=='%') ) {s = 2;}
 
-                        else if ( (LA20_43=='*'||LA20_43==':'||LA20_43=='>'||LA20_43=='['||LA20_43==']'||LA20_43=='{'||LA20_43=='}') ) {s = 44;}
+                        else if ( (LA20_0=='\r') ) {s = 3;}
 
-                        else if ( (LA20_43==',') ) {s = 45;}
+                        else if ( (LA20_0=='\n') ) {s = 4;}
 
-                        else if ( (LA20_43=='\n'||LA20_43=='\r'||(LA20_43>='\"' && LA20_43<='#')||(LA20_43>='(' && LA20_43<=')')||LA20_43=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_0==' ') ) {s = 5;}
 
-                        else s = 57;
+                        else if ( (LA20_0=='-') ) {s = 6;}
 
-                         
-                        input.seek(index20_43);
-                        if ( s>=0 ) return s;
-                        break;
-                    case 37 : 
-                        int LA20_66 = input.LA(1);
+                        else if ( (LA20_0=='@') ) {s = 7;}
 
-                         
-                        int index20_66 = input.index();
-                        input.rewind();
-                        s = -1;
-                        if ( (LA20_66=='\t'||LA20_66==' ') && ((( isHead() )||( isValue() )))) {s = 65;}
+                        else if ( (LA20_0=='\t') ) {s = 8;}
 
-                        else if ( ((LA20_66>='\u0000' && LA20_66<='\b')||(LA20_66>='\u000B' && LA20_66<='\f')||(LA20_66>='\u000E' && LA20_66<='\u001F')||LA20_66=='!'||(LA20_66>='$' && LA20_66<='\'')||LA20_66=='+'||(LA20_66>='-' && LA20_66<='9')||(LA20_66>=';' && LA20_66<='=')||(LA20_66>='?' && LA20_66<='Z')||(LA20_66>='^' && LA20_66<='z')||LA20_66=='|'||(LA20_66>='~' && LA20_66<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 66;}
+                        else if ( (LA20_0=='(') ) {s = 9;}
 
-                        else if ( (LA20_66=='*'||LA20_66==':'||LA20_66=='>'||LA20_66=='['||LA20_66==']'||LA20_66=='{'||LA20_66=='}') && ((( isValue() )||( isHead() )))) {s = 67;}
+                        else if ( (LA20_0==')') ) {s = 10;}
 
-                        else if ( (LA20_66==',') && ((( isHead() )||( isValue() )))) {s = 68;}
+                        else if ( (LA20_0==',') ) {s = 11;}
 
-                        else if ( (LA20_66=='\n'||LA20_66=='\r'||(LA20_66>='\"' && LA20_66<='#')||(LA20_66>='(' && LA20_66<=')')||LA20_66=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_0==':') ) {s = 12;}
 
-                        else s = 64;
+                        else if ( (LA20_0=='>') ) {s = 13;}
+
+                        else if ( (LA20_0=='|') ) {s = 14;}
+
+                        else if ( (LA20_0=='*') ) {s = 15;}
+
+                        else if ( (LA20_0=='+') ) {s = 16;}
+
+                        else if ( (LA20_0=='[') ) {s = 17;}
+
+                        else if ( (LA20_0==']') ) {s = 18;}
+
+                        else if ( (LA20_0=='?') ) {s = 19;}
+
+                        else if ( (LA20_0=='\"') ) {s = 20;}
+
+                        else if ( ((LA20_0>='\u0000' && LA20_0<='\b')||(LA20_0>='\u000B' && LA20_0<='\f')||(LA20_0>='\u000E' && LA20_0<='\u001F')||LA20_0=='!'||LA20_0=='$'||LA20_0=='&'||(LA20_0>='.' && LA20_0<='9')||(LA20_0>=';' && LA20_0<='=')||(LA20_0>='A' && LA20_0<='Z')||(LA20_0>='^' && LA20_0<='z')||(LA20_0>='~' && LA20_0<='\uFFFF')) ) {s = 21;}
+
+                        else if ( (LA20_0=='{') && ((( isValue() )||( isHead() )))) {s = 22;}
+
+                        else if ( (LA20_0=='\''||LA20_0=='\\'||LA20_0=='}') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_66);
+                        input.seek(index20_0);
                         if ( s>=0 ) return s;
                         break;
                     case 38 : 
-                        int LA20_56 = input.LA(1);
+                        int LA20_76 = input.LA(1);
 
                          
-                        int index20_56 = input.index();
+                        int index20_76 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_56=='\"') ) {s = 89;}
+                        if ( (LA20_76=='\t'||LA20_76==' ') ) {s = 75;}
 
-                        else if ( ((LA20_56>='\u0000' && LA20_56<='\t')||(LA20_56>='\u000B' && LA20_56<='\f')||(LA20_56>='\u000E' && LA20_56<='!')||(LA20_56>='#' && LA20_56<='[')||(LA20_56>=']' && LA20_56<='\uFFFF')) ) {s = 90;}
+                        else if ( ((LA20_76>='\u0000' && LA20_76<='\b')||(LA20_76>='\u000B' && LA20_76<='\f')||(LA20_76>='\u000E' && LA20_76<='\u001F')||LA20_76=='!'||(LA20_76>='$' && LA20_76<='\'')||LA20_76=='+'||(LA20_76>='-' && LA20_76<='9')||(LA20_76>=';' && LA20_76<='=')||(LA20_76>='?' && LA20_76<='Z')||(LA20_76>='^' && LA20_76<='z')||LA20_76=='|'||(LA20_76>='~' && LA20_76<='\uFFFF')) ) {s = 76;}
 
-                        else if ( (LA20_56=='\\') ) {s = 91;}
+                        else if ( (LA20_76=='*'||LA20_76==':'||LA20_76=='>'||LA20_76=='['||LA20_76==']'||LA20_76=='{'||LA20_76=='}') ) {s = 77;}
 
-                        else if ( (LA20_56=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_76>='(' && LA20_76<=')')||LA20_76==',') ) {s = 78;}
+
+                        else if ( (LA20_76=='\n'||LA20_76=='\r'||(LA20_76>='\"' && LA20_76<='#')||LA20_76=='\\') && (( isHead() ))) {s = 23;}
+
+                        else s = 74;
 
                          
-                        input.seek(index20_56);
+                        input.seek(index20_76);
                         if ( s>=0 ) return s;
                         break;
                     case 39 : 
-                        int LA20_28 = input.LA(1);
+                        int LA20_97 = input.LA(1);
 
                          
-                        int index20_28 = input.index();
+                        int index20_97 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (( currentState() != State.INIT )) ) {s = 61;}
+                        if ( (LA20_97=='\"') ) {s = 89;}
 
-                        else if ( (true) ) {s = 62;}
+                        else if ( ((LA20_97>='\u0000' && LA20_97<='\t')||(LA20_97>='\u000B' && LA20_97<='\f')||(LA20_97>='\u000E' && LA20_97<='!')||(LA20_97>='#' && LA20_97<='[')||(LA20_97>=']' && LA20_97<='\uFFFF')) ) {s = 90;}
+
+                        else if ( (LA20_97=='\\') ) {s = 91;}
+
+                        else if ( (LA20_97=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_28);
+                        input.seek(index20_97);
                         if ( s>=0 ) return s;
                         break;
                     case 40 : 
-                        int LA20_18 = input.LA(1);
+                        int LA20_8 = input.LA(1);
 
                          
-                        int index20_18 = input.index();
+                        int index20_8 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_18>='\u0000' && LA20_18<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( (LA20_8=='\n'||LA20_8=='\r') ) {s = 28;}
 
-                        else s = 48;
+                        else if ( (LA20_8=='\t'||LA20_8==' ') ) {s = 31;}
+
+                        else if ( ((LA20_8>='\u0000' && LA20_8<='\b')||(LA20_8>='\u000B' && LA20_8<='\f')||(LA20_8>='\u000E' && LA20_8<='\u001F')||(LA20_8>='!' && LA20_8<='\"')||LA20_8=='$'||(LA20_8>='&' && LA20_8<=',')||(LA20_8>='.' && LA20_8<='?')||(LA20_8>='A' && LA20_8<='\uFFFF')) && (( isHead() ))) {s = 23;}
+
+                        else s = 27;
 
                          
-                        input.seek(index20_18);
+                        input.seek(index20_8);
                         if ( s>=0 ) return s;
                         break;
                     case 41 : 
-                        int LA20_51 = input.LA(1);
+                        int LA20_75 = input.LA(1);
 
                          
-                        int index20_51 = input.index();
+                        int index20_75 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_51=='\t'||LA20_51==' ') ) {s = 75;}
+                        if ( (LA20_75=='\t'||LA20_75==' ') ) {s = 75;}
 
-                        else if ( ((LA20_51>='\u0000' && LA20_51<='\b')||(LA20_51>='\u000B' && LA20_51<='\f')||(LA20_51>='\u000E' && LA20_51<='\u001F')||LA20_51=='!'||(LA20_51>='$' && LA20_51<='\'')||LA20_51=='+'||(LA20_51>='-' && LA20_51<='9')||(LA20_51>=';' && LA20_51<='=')||(LA20_51>='?' && LA20_51<='Z')||(LA20_51>='^' && LA20_51<='z')||LA20_51=='|'||(LA20_51>='~' && LA20_51<='\uFFFF')) ) {s = 76;}
+                        else if ( ((LA20_75>='\u0000' && LA20_75<='\b')||(LA20_75>='\u000B' && LA20_75<='\f')||(LA20_75>='\u000E' && LA20_75<='\u001F')||LA20_75=='!'||(LA20_75>='$' && LA20_75<='\'')||LA20_75=='+'||(LA20_75>='-' && LA20_75<='9')||(LA20_75>=';' && LA20_75<='=')||(LA20_75>='?' && LA20_75<='Z')||(LA20_75>='^' && LA20_75<='z')||LA20_75=='|'||(LA20_75>='~' && LA20_75<='\uFFFF')) ) {s = 76;}
 
-                        else if ( (LA20_51=='*'||LA20_51==':'||LA20_51=='>'||LA20_51=='['||LA20_51==']'||LA20_51=='{'||LA20_51=='}') ) {s = 77;}
+                        else if ( (LA20_75=='*'||LA20_75==':'||LA20_75=='>'||LA20_75=='['||LA20_75==']'||LA20_75=='{'||LA20_75=='}') ) {s = 77;}
 
-                        else if ( (LA20_51==',') ) {s = 78;}
+                        else if ( ((LA20_75>='(' && LA20_75<=')')||LA20_75==',') ) {s = 78;}
 
-                        else if ( (LA20_51=='\n'||LA20_51=='\r'||(LA20_51>='\"' && LA20_51<='#')||(LA20_51>='(' && LA20_51<=')')||LA20_51=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_75=='\n'||LA20_75=='\r'||(LA20_75>='\"' && LA20_75<='#')||LA20_75=='\\') && (( isHead() ))) {s = 23;}
 
                         else s = 74;
 
                          
-                        input.seek(index20_51);
+                        input.seek(index20_75);
                         if ( s>=0 ) return s;
                         break;
                     case 42 : 
-                        int LA20_17 = input.LA(1);
+                        int LA20_29 = input.LA(1);
 
                          
-                        int index20_17 = input.index();
+                        int index20_29 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_17>='\u0000' && LA20_17<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( (LA20_29=='\n'||LA20_29=='\r') ) {s = 28;}
 
-                        else s = 47;
+                        else if ( (LA20_29==' ') ) {s = 29;}
+
+                        else if ( (LA20_29=='@') && (( isHead() ))) {s = 30;}
+
+                        else if ( (LA20_29=='\t') ) {s = 31;}
+
+                        else if ( ((LA20_29>='\u0000' && LA20_29<='\b')||(LA20_29>='\u000B' && LA20_29<='\f')||(LA20_29>='\u000E' && LA20_29<='\u001F')||(LA20_29>='!' && LA20_29<='\"')||LA20_29=='$'||(LA20_29>='&' && LA20_29<=',')||(LA20_29>='.' && LA20_29<='?')||(LA20_29>='A' && LA20_29<='\uFFFF')) && (( isHead() ))) {s = 23;}
+
+                        else if ( (LA20_29=='-') ) {s = 6;}
+
+                        else s = 61;
 
                          
-                        input.seek(index20_17);
+                        input.seek(index20_29);
                         if ( s>=0 ) return s;
                         break;
                     case 43 : 
-                        int LA20_80 = input.LA(1);
+                        int LA20_104 = input.LA(1);
 
                          
-                        int index20_80 = input.index();
+                        int index20_104 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_80=='\n'||LA20_80=='\r') && (( isHead() ))) {s = 23;}
-
-                        else if ( (LA20_80=='#') ) {s = 56;}
-
-                        else if ( (LA20_80=='\"') ) {s = 55;}
+                        if ( ((LA20_104>='\u0000' && LA20_104<='/')||(LA20_104>=':' && LA20_104<='@')||(LA20_104>='G' && LA20_104<='`')||(LA20_104>='g' && LA20_104<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else if ( ((LA20_80>='\u0000' && LA20_80<='\t')||(LA20_80>='\u000B' && LA20_80<='\f')||(LA20_80>='\u000E' && LA20_80<='!')||(LA20_80>='$' && LA20_80<='[')||(LA20_80>=']' && LA20_80<='\uFFFF')) ) {s = 53;}
-
-                        else if ( (LA20_80=='\\') ) {s = 54;}
+                        else if ( ((LA20_104>='0' && LA20_104<='9')||(LA20_104>='A' && LA20_104<='F')||(LA20_104>='a' && LA20_104<='f')) ) {s = 106;}
 
                          
-                        input.seek(index20_80);
+                        input.seek(index20_104);
                         if ( s>=0 ) return s;
                         break;
                     case 44 : 
-                        int LA20_69 = input.LA(1);
+                        int LA20_27 = input.LA(1);
 
                          
-                        int index20_69 = input.index();
+                        int index20_27 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_69>='\u0000' && LA20_69<='\b')||(LA20_69>='\u000B' && LA20_69<='\f')||(LA20_69>='\u000E' && LA20_69<='\u001F')||LA20_69=='!'||(LA20_69>='$' && LA20_69<='\'')||LA20_69=='+'||(LA20_69>='-' && LA20_69<='9')||(LA20_69>=';' && LA20_69<='=')||(LA20_69>='?' && LA20_69<='Z')||(LA20_69>='^' && LA20_69<='z')||LA20_69=='|'||(LA20_69>='~' && LA20_69<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 70;}
-
-                        else if ( (LA20_69=='*'||LA20_69==':'||LA20_69=='>'||LA20_69=='['||LA20_69==']'||LA20_69=='{'||LA20_69=='}') && ((( isHead() )||( isValue() )))) {s = 71;}
-
-                        else if ( (LA20_69==',') && ((( isHead() )||( isValue() )))) {s = 72;}
+                        if ( (( !isHead() )) ) {s = 61;}
 
-                        else if ( (LA20_69=='\t'||LA20_69==' ') && ((( isHead() )||( isValue() )))) {s = 69;}
-
-                        else if ( (LA20_69=='\r'||(LA20_69>='\"' && LA20_69<='#')||(LA20_69>='(' && LA20_69<=')')||LA20_69=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (true) ) {s = 62;}
 
                          
-                        input.seek(index20_69);
+                        input.seek(index20_27);
                         if ( s>=0 ) return s;
                         break;
                     case 45 : 
-                        int LA20_42 = input.LA(1);
+                        int LA20_101 = input.LA(1);
 
                          
-                        int index20_42 = input.index();
+                        int index20_101 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_42>='\u0000' && LA20_42<='\b')||(LA20_42>='\u000B' && LA20_42<='\f')||(LA20_42>='\u000E' && LA20_42<='\u001F')||LA20_42=='!'||(LA20_42>='$' && LA20_42<='\'')||LA20_42=='+'||(LA20_42>='-' && LA20_42<='9')||(LA20_42>=';' && LA20_42<='=')||(LA20_42>='?' && LA20_42<='Z')||(LA20_42>='^' && LA20_42<='z')||LA20_42=='|'||(LA20_42>='~' && LA20_42<='\uFFFF')) ) {s = 43;}
-
-                        else if ( (LA20_42=='*'||LA20_42==':'||LA20_42=='>'||LA20_42=='['||LA20_42==']'||LA20_42=='{'||LA20_42=='}') ) {s = 44;}
-
-                        else if ( (LA20_42==',') ) {s = 45;}
-
-                        else if ( (LA20_42=='\t'||LA20_42==' ') ) {s = 42;}
+                        if ( ((LA20_101>='0' && LA20_101<='9')||(LA20_101>='A' && LA20_101<='F')||(LA20_101>='a' && LA20_101<='f')) ) {s = 103;}
 
-                        else if ( (LA20_42=='\n'||LA20_42=='\r'||(LA20_42>='\"' && LA20_42<='#')||(LA20_42>='(' && LA20_42<=')')||LA20_42=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_101>='\u0000' && LA20_101<='\t')||(LA20_101>='\u000B' && LA20_101<='/')||(LA20_101>=':' && LA20_101<='@')||(LA20_101>='G' && LA20_101<='`')||(LA20_101>='g' && LA20_101<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_42);
+                        input.seek(index20_101);
                         if ( s>=0 ) return s;
                         break;
                     case 46 : 
-                        int LA20_65 = input.LA(1);
+                        int LA20_56 = input.LA(1);
 
                          
-                        int index20_65 = input.index();
+                        int index20_56 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_65>='\u0000' && LA20_65<='\b')||(LA20_65>='\u000B' && LA20_65<='\f')||(LA20_65>='\u000E' && LA20_65<='\u001F')||LA20_65=='!'||(LA20_65>='$' && LA20_65<='\'')||LA20_65=='+'||(LA20_65>='-' && LA20_65<='9')||(LA20_65>=';' && LA20_65<='=')||(LA20_65>='?' && LA20_65<='Z')||(LA20_65>='^' && LA20_65<='z')||LA20_65=='|'||(LA20_65>='~' && LA20_65<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 66;}
-
-                        else if ( (LA20_65=='*'||LA20_65==':'||LA20_65=='>'||LA20_65=='['||LA20_65==']'||LA20_65=='{'||LA20_65=='}') && ((( isValue() )||( isHead() )))) {s = 67;}
+                        if ( (LA20_56=='\"') ) {s = 89;}
 
-                        else if ( (LA20_65==',') && ((( isHead() )||( isValue() )))) {s = 68;}
+                        else if ( ((LA20_56>='\u0000' && LA20_56<='\t')||(LA20_56>='\u000B' && LA20_56<='\f')||(LA20_56>='\u000E' && LA20_56<='!')||(LA20_56>='#' && LA20_56<='[')||(LA20_56>=']' && LA20_56<='\uFFFF')) ) {s = 90;}
 
-                        else if ( (LA20_65=='\t'||LA20_65==' ') && ((( isHead() )||( isValue() )))) {s = 65;}
+                        else if ( (LA20_56=='\\') ) {s = 91;}
 
-                        else if ( (LA20_65=='\n'||LA20_65=='\r'||(LA20_65>='\"' && LA20_65<='#')||(LA20_65>='(' && LA20_65<=')')||LA20_65=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_56=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_65);
+                        input.seek(index20_56);
                         if ( s>=0 ) return s;
                         break;
                     case 47 : 
-                        int LA20_90 = input.LA(1);
+                        int LA20_96 = input.LA(1);
 
                          
-                        int index20_90 = input.index();
+                        int index20_96 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_90=='\"') ) {s = 89;}
+                        if ( (LA20_96=='\"') ) {s = 89;}
 
-                        else if ( ((LA20_90>='\u0000' && LA20_90<='\t')||(LA20_90>='\u000B' && LA20_90<='\f')||(LA20_90>='\u000E' && LA20_90<='!')||(LA20_90>='#' && LA20_90<='[')||(LA20_90>=']' && LA20_90<='\uFFFF')) ) {s = 90;}
+                        else if ( ((LA20_96>='\u0000' && LA20_96<='\t')||(LA20_96>='\u000B' && LA20_96<='\f')||(LA20_96>='\u000E' && LA20_96<='!')||(LA20_96>='#' && LA20_96<='[')||(LA20_96>=']' && LA20_96<='\uFFFF')) ) {s = 90;}
 
-                        else if ( (LA20_90=='\\') ) {s = 91;}
+                        else if ( (LA20_96=='\\') ) {s = 91;}
 
-                        else if ( (LA20_90=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_96=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_90);
+                        input.seek(index20_96);
                         if ( s>=0 ) return s;
                         break;
                     case 48 : 
-                        int LA20_71 = input.LA(1);
+                        int LA20_52 = input.LA(1);
 
                          
-                        int index20_71 = input.index();
+                        int index20_52 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_71=='\t'||LA20_71==' ') && ((( isHead() )||( isValue() )))) {s = 69;}
+                        if ( (LA20_52=='\t'||LA20_52==' ') ) {s = 75;}
 
-                        else if ( ((LA20_71>='\u0000' && LA20_71<='\b')||(LA20_71>='\u000B' && LA20_71<='\f')||(LA20_71>='\u000E' && LA20_71<='\u001F')||LA20_71=='!'||(LA20_71>='$' && LA20_71<='\'')||LA20_71=='+'||(LA20_71>='-' && LA20_71<='9')||(LA20_71>=';' && LA20_71<='=')||(LA20_71>='?' && LA20_71<='Z')||(LA20_71>='^' && LA20_71<='z')||LA20_71=='|'||(LA20_71>='~' && LA20_71<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 70;}
+                        else if ( ((LA20_52>='\u0000' && LA20_52<='\b')||(LA20_52>='\u000B' && LA20_52<='\f')||(LA20_52>='\u000E' && LA20_52<='\u001F')||LA20_52=='!'||(LA20_52>='$' && LA20_52<='\'')||LA20_52=='+'||(LA20_52>='-' && LA20_52<='9')||(LA20_52>=';' && LA20_52<='=')||(LA20_52>='?' && LA20_52<='Z')||(LA20_52>='^' && LA20_52<='z')||LA20_52=='|'||(LA20_52>='~' && LA20_52<='\uFFFF')) ) {s = 76;}
 
-                        else if ( (LA20_71=='*'||LA20_71==':'||LA20_71=='>'||LA20_71=='['||LA20_71==']'||LA20_71=='{'||LA20_71=='}') && ((( isHead() )||( isValue() )))) {s = 71;}
+                        else if ( (LA20_52=='*'||LA20_52==':'||LA20_52=='>'||LA20_52=='['||LA20_52==']'||LA20_52=='{'||LA20_52=='}') ) {s = 77;}
 
-                        else if ( (LA20_71==',') && ((( isHead() )||( isValue() )))) {s = 72;}
+                        else if ( ((LA20_52>='(' && LA20_52<=')')||LA20_52==',') ) {s = 78;}
 
-                        else if ( (LA20_71=='\r'||(LA20_71>='\"' && LA20_71<='#')||(LA20_71>='(' && LA20_71<=')')||LA20_71=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_52=='\n'||LA20_52=='\r'||(LA20_52>='\"' && LA20_52<='#')||LA20_52=='\\') && (( isHead() ))) {s = 23;}
 
-                        else s = 64;
+                        else s = 74;
 
                          
-                        input.seek(index20_71);
+                        input.seek(index20_52);
                         if ( s>=0 ) return s;
                         break;
                     case 49 : 
-                        int LA20_5 = input.LA(1);
+                        int LA20_91 = input.LA(1);
 
                          
-                        int index20_5 = input.index();
+                        int index20_91 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_5=='-') ) {s = 6;}
+                        if ( (LA20_91=='\"') ) {s = 93;}
 
-                        else if ( (LA20_5==' ') ) {s = 27;}
+                        else if ( (LA20_91=='\\') ) {s = 94;}
+
+                        else if ( (LA20_91=='/') ) {s = 95;}
 
-                        else if ( (LA20_5=='\n'||LA20_5=='\r') ) {s = 29;}
+                        else if ( (LA20_91=='b') ) {s = 96;}
 
-                        else if ( (LA20_5=='\t') ) {s = 30;}
+                        else if ( (LA20_91=='f') ) {s = 97;}
 
-                        else if ( (LA20_5=='@') && (( isHead() ))) {s = 31;}
+                        else if ( (LA20_91=='n') ) {s = 98;}
 
-                        else if ( ((LA20_5>='\u0000' && LA20_5<='\b')||(LA20_5>='\u000B' && LA20_5<='\f')||(LA20_5>='\u000E' && LA20_5<='\u001F')||(LA20_5>='!' && LA20_5<='\"')||LA20_5=='$'||(LA20_5>='&' && LA20_5<=',')||(LA20_5>='.' && LA20_5<='?')||(LA20_5>='A' && LA20_5<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_91=='r') ) {s = 99;}
 
-                        else s = 28;
+                        else if ( (LA20_91=='t') ) {s = 100;}
+
+                        else if ( (LA20_91=='u') ) {s = 101;}
+
+                        else if ( ((LA20_91>='\u0000' && LA20_91<='\t')||(LA20_91>='\u000B' && LA20_91<='!')||(LA20_91>='#' && LA20_91<='.')||(LA20_91>='0' && LA20_91<='[')||(LA20_91>=']' && LA20_91<='a')||(LA20_91>='c' && LA20_91<='e')||(LA20_91>='g' && LA20_91<='m')||(LA20_91>='o' && LA20_91<='q')||LA20_91=='s'||(LA20_91>='v' && LA20_91<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_5);
+                        input.seek(index20_91);
                         if ( s>=0 ) return s;
                         break;
                     case 50 : 
-                        int LA20_22 = input.LA(1);
+                        int LA20_11 = input.LA(1);
 
                          
-                        int index20_22 = input.index();
+                        int index20_11 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_22>='\u0000' && LA20_22<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_11>='\u0000' && LA20_11<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else s = 58;
+                        else s = 35;
 
                          
-                        input.seek(index20_22);
+                        input.seek(index20_11);
                         if ( s>=0 ) return s;
                         break;
                     case 51 : 
-                        int LA20_47 = input.LA(1);
+                        int LA20_55 = input.LA(1);
 
                          
-                        int index20_47 = input.index();
+                        int index20_55 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (!((( isValue() )))) ) {s = 73;}
+                        if ( ((LA20_55>='\u0000' && LA20_55<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else if ( (( isValue() )) ) {s = 58;}
+                        else s = 88;
 
                          
-                        input.seek(index20_47);
+                        input.seek(index20_55);
                         if ( s>=0 ) return s;
                         break;
                     case 52 : 
-                        int LA20_104 = input.LA(1);
+                        int LA20_105 = input.LA(1);
 
                          
-                        int index20_104 = input.index();
+                        int index20_105 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_104>='0' && LA20_104<='9')||(LA20_104>='A' && LA20_104<='F')||(LA20_104>='a' && LA20_104<='f')) ) {s = 106;}
+                        if ( ((LA20_105>='0' && LA20_105<='9')||(LA20_105>='A' && LA20_105<='F')||(LA20_105>='a' && LA20_105<='f')) ) {s = 107;}
 
-                        else if ( ((LA20_104>='\u0000' && LA20_104<='/')||(LA20_104>=':' && LA20_104<='@')||(LA20_104>='G' && LA20_104<='`')||(LA20_104>='g' && LA20_104<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_105>='\u0000' && LA20_105<='\t')||(LA20_105>='\u000B' && LA20_105<='/')||(LA20_105>=':' && LA20_105<='@')||(LA20_105>='G' && LA20_105<='`')||(LA20_105>='g' && LA20_105<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_104);
+                        input.seek(index20_105);
                         if ( s>=0 ) return s;
                         break;
                     case 53 : 
-                        int LA20_16 = input.LA(1);
+                        int LA20_5 = input.LA(1);
 
                          
-                        int index20_16 = input.index();
+                        int index20_5 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_16=='\t'||LA20_16==' ') ) {s = 42;}
+                        if ( (LA20_5=='\n'||LA20_5=='\r') ) {s = 28;}
 
-                        else if ( ((LA20_16>='\u0000' && LA20_16<='\b')||(LA20_16>='\u000B' && LA20_16<='\f')||(LA20_16>='\u000E' && LA20_16<='\u001F')||LA20_16=='!'||(LA20_16>='$' && LA20_16<='\'')||LA20_16=='+'||(LA20_16>='-' && LA20_16<='9')||(LA20_16>=';' && LA20_16<='=')||(LA20_16>='?' && LA20_16<='Z')||(LA20_16>='^' && LA20_16<='z')||LA20_16=='|'||(LA20_16>='~' && LA20_16<='\uFFFF')) ) {s = 43;}
+                        else if ( (LA20_5==' ') ) {s = 29;}
 
-                        else if ( (LA20_16=='*'||LA20_16==':'||LA20_16=='>'||LA20_16=='['||LA20_16==']'||LA20_16=='{'||LA20_16=='}') ) {s = 44;}
+                        else if ( (LA20_5=='@') && (( isHead() ))) {s = 30;}
 
-                        else if ( (LA20_16==',') ) {s = 45;}
+                        else if ( (LA20_5=='\t') ) {s = 31;}
 
-                        else if ( (LA20_16=='\n'||LA20_16=='\r'||(LA20_16>='\"' && LA20_16<='#')||(LA20_16>='(' && LA20_16<=')')||LA20_16=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_5>='\u0000' && LA20_5<='\b')||(LA20_5>='\u000B' && LA20_5<='\f')||(LA20_5>='\u000E' && LA20_5<='\u001F')||(LA20_5>='!' && LA20_5<='\"')||LA20_5=='$'||(LA20_5>='&' && LA20_5<=',')||(LA20_5>='.' && LA20_5<='?')||(LA20_5>='A' && LA20_5<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else s = 46;
+                        else if ( (LA20_5=='-') ) {s = 6;}
+
+                        else s = 27;
 
                          
-                        input.seek(index20_16);
+                        input.seek(index20_5);
                         if ( s>=0 ) return s;
                         break;
                     case 54 : 
-                        int LA20_93 = input.LA(1);
+                        int LA20_31 = input.LA(1);
 
                          
-                        int index20_93 = input.index();
+                        int index20_31 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_93=='\r') && (( isHead() ))) {s = 23;}
+                        if ( (LA20_31=='\n'||LA20_31=='\r') ) {s = 28;}
 
-                        else if ( (LA20_93=='\"') ) {s = 89;}
+                        else if ( (LA20_31=='\t'||LA20_31==' ') ) {s = 31;}
 
-                        else if ( ((LA20_93>='\u0000' && LA20_93<='\t')||(LA20_93>='\u000B' && LA20_93<='\f')||(LA20_93>='\u000E' && LA20_93<='!')||(LA20_93>='#' && LA20_93<='[')||(LA20_93>=']' && LA20_93<='\uFFFF')) ) {s = 90;}
+                        else if ( ((LA20_31>='\u0000' && LA20_31<='\b')||(LA20_31>='\u000B' && LA20_31<='\f')||(LA20_31>='\u000E' && LA20_31<='\u001F')||(LA20_31>='!' && LA20_31<='\"')||LA20_31=='$'||(LA20_31>='&' && LA20_31<=',')||(LA20_31>='.' && LA20_31<='?')||(LA20_31>='A' && LA20_31<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else if ( (LA20_93=='\\') ) {s = 91;}
+                        else s = 61;
 
                          
-                        input.seek(index20_93);
+                        input.seek(index20_31);
                         if ( s>=0 ) return s;
                         break;
                     case 55 : 
-                        int LA20_106 = input.LA(1);
+                        int LA20_84 = input.LA(1);
 
                          
-                        int index20_106 = input.index();
+                        int index20_84 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_106=='\n'||LA20_106=='\r') && (( isHead() ))) {s = 23;}
+                        if ( (LA20_84=='\n'||LA20_84=='\r') && (( isHead() ))) {s = 23;}
 
-                        else if ( (LA20_106=='#') ) {s = 56;}
+                        else if ( (LA20_84=='#') ) {s = 56;}
 
-                        else if ( (LA20_106=='\"') ) {s = 55;}
+                        else if ( (LA20_84=='\"') ) {s = 55;}
 
-                        else if ( ((LA20_106>='\u0000' && LA20_106<='\t')||(LA20_106>='\u000B' && LA20_106<='\f')||(LA20_106>='\u000E' && LA20_106<='!')||(LA20_106>='$' && LA20_106<='[')||(LA20_106>=']' && LA20_106<='\uFFFF')) ) {s = 53;}
+                        else if ( ((LA20_84>='\u0000' && LA20_84<='\t')||(LA20_84>='\u000B' && LA20_84<='\f')||(LA20_84>='\u000E' && LA20_84<='!')||(LA20_84>='$' && LA20_84<='[')||(LA20_84>=']' && LA20_84<='\uFFFF')) ) {s = 53;}
 
-                        else if ( (LA20_106=='\\') ) {s = 54;}
+                        else if ( (LA20_84=='\\') ) {s = 54;}
 
                          
-                        input.seek(index20_106);
+                        input.seek(index20_84);
                         if ( s>=0 ) return s;
                         break;
                     case 56 : 
-                        int LA20_53 = input.LA(1);
+                        int LA20_98 = input.LA(1);
 
                          
-                        int index20_53 = input.index();
+                        int index20_98 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_53=='\"') ) {s = 55;}
-
-                        else if ( (LA20_53=='#') ) {s = 56;}
+                        if ( (LA20_98=='\"') ) {s = 89;}
 
-                        else if ( (LA20_53=='\\') ) {s = 54;}
+                        else if ( ((LA20_98>='\u0000' && LA20_98<='\t')||(LA20_98>='\u000B' && LA20_98<='\f')||(LA20_98>='\u000E' && LA20_98<='!')||(LA20_98>='#' && LA20_98<='[')||(LA20_98>=']' && LA20_98<='\uFFFF')) ) {s = 90;}
 
-                        else if ( (LA20_53=='\n'||LA20_53=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_98=='\\') ) {s = 91;}
 
-                        else if ( ((LA20_53>='\u0000' && LA20_53<='\t')||(LA20_53>='\u000B' && LA20_53<='\f')||(LA20_53>='\u000E' && LA20_53<='!')||(LA20_53>='$' && LA20_53<='[')||(LA20_53>=']' && LA20_53<='\uFFFF')) ) {s = 53;}
+                        else if ( (LA20_98=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_53);
+                        input.seek(index20_98);
                         if ( s>=0 ) return s;
                         break;
                     case 57 : 
-                        int LA20_30 = input.LA(1);
+                        int LA20_14 = input.LA(1);
 
                          
-                        int index20_30 = input.index();
+                        int index20_14 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_30=='\n'||LA20_30=='\r') ) {s = 29;}
-
-                        else if ( (LA20_30=='\t'||LA20_30==' ') ) {s = 30;}
-
-                        else if ( ((LA20_30>='\u0000' && LA20_30<='\b')||(LA20_30>='\u000B' && LA20_30<='\f')||(LA20_30>='\u000E' && LA20_30<='\u001F')||(LA20_30>='!' && LA20_30<='\"')||LA20_30=='$'||(LA20_30>='&' && LA20_30<=',')||(LA20_30>='.' && LA20_30<='?')||(LA20_30>='A' && LA20_30<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_14>='\u0000' && LA20_14<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else s = 61;
+                        else s = 40;
 
                          
-                        input.seek(index20_30);
+                        input.seek(index20_14);
                         if ( s>=0 ) return s;
                         break;
                     case 58 : 
-                        int LA20_75 = input.LA(1);
+                        int LA20_36 = input.LA(1);
 
                          
-                        int index20_75 = input.index();
+                        int index20_36 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_75>='\u0000' && LA20_75<='\b')||(LA20_75>='\u000B' && LA20_75<='\f')||(LA20_75>='\u000E' && LA20_75<='\u001F')||LA20_75=='!'||(LA20_75>='$' && LA20_75<='\'')||LA20_75=='+'||(LA20_75>='-' && LA20_75<='9')||(LA20_75>=';' && LA20_75<='=')||(LA20_75>='?' && LA20_75<='Z')||(LA20_75>='^' && LA20_75<='z')||LA20_75=='|'||(LA20_75>='~' && LA20_75<='\uFFFF')) ) {s = 76;}
+                        if ( (LA20_36=='\t'||LA20_36==' ') && ((( isValue() )||( isHead() )))) {s = 65;}
 
-                        else if ( (LA20_75=='*'||LA20_75==':'||LA20_75=='>'||LA20_75=='['||LA20_75==']'||LA20_75=='{'||LA20_75=='}') ) {s = 77;}
+                        else if ( ((LA20_36>='\u0000' && LA20_36<='\b')||(LA20_36>='\u000B' && LA20_36<='\f')||(LA20_36>='\u000E' && LA20_36<='\u001F')||LA20_36=='!'||(LA20_36>='$' && LA20_36<='\'')||LA20_36=='+'||(LA20_36>='-' && LA20_36<='9')||(LA20_36>=';' && LA20_36<='=')||(LA20_36>='?' && LA20_36<='Z')||(LA20_36>='^' && LA20_36<='z')||LA20_36=='|'||(LA20_36>='~' && LA20_36<='\uFFFF')) && ((( isValue() )||( isHead() )))) {s = 66;}
 
-                        else if ( (LA20_75==',') ) {s = 78;}
+                        else if ( (LA20_36=='*'||LA20_36==':'||LA20_36=='>'||LA20_36=='['||LA20_36==']'||LA20_36=='{'||LA20_36=='}') && ((( isValue() )||( isHead() )))) {s = 67;}
 
-                        else if ( (LA20_75=='\t'||LA20_75==' ') ) {s = 75;}
+                        else if ( ((LA20_36>='(' && LA20_36<=')')||LA20_36==',') && ((( isValue() )||( isHead() )))) {s = 68;}
 
-                        else if ( (LA20_75=='\n'||LA20_75=='\r'||(LA20_75>='\"' && LA20_75<='#')||(LA20_75>='(' && LA20_75<=')')||LA20_75=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_36=='\n'||LA20_36=='\r'||(LA20_36>='\"' && LA20_36<='#')||LA20_36=='\\') && (( isHead() ))) {s = 23;}
+
+                        else s = 64;
 
                          
-                        input.seek(index20_75);
+                        input.seek(index20_36);
                         if ( s>=0 ) return s;
                         break;
                     case 59 : 
-                        int LA20_99 = input.LA(1);
+                        int LA20_87 = input.LA(1);
 
                          
-                        int index20_99 = input.index();
+                        int index20_87 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_99=='\r') && (( isHead() ))) {s = 23;}
-
-                        else if ( (LA20_99=='\"') ) {s = 89;}
-
-                        else if ( ((LA20_99>='\u0000' && LA20_99<='\t')||(LA20_99>='\u000B' && LA20_99<='\f')||(LA20_99>='\u000E' && LA20_99<='!')||(LA20_99>='#' && LA20_99<='[')||(LA20_99>=']' && LA20_99<='\uFFFF')) ) {s = 90;}
+                        if ( ((LA20_87>='0' && LA20_87<='9')||(LA20_87>='A' && LA20_87<='F')||(LA20_87>='a' && LA20_87<='f')) ) {s = 92;}
 
-                        else if ( (LA20_99=='\\') ) {s = 91;}
+                        else if ( ((LA20_87>='\u0000' && LA20_87<='/')||(LA20_87>=':' && LA20_87<='@')||(LA20_87>='G' && LA20_87<='`')||(LA20_87>='g' && LA20_87<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_99);
+                        input.seek(index20_87);
                         if ( s>=0 ) return s;
                         break;
                     case 60 : 
-                        int LA20_19 = input.LA(1);
+                        int LA20_100 = input.LA(1);
 
                          
-                        int index20_19 = input.index();
+                        int index20_100 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_19>='\u0000' && LA20_19<='\b')||(LA20_19>='\u000B' && LA20_19<='\f')||(LA20_19>='\u000E' && LA20_19<='\u001F')||LA20_19=='!'||(LA20_19>='$' && LA20_19<='\'')||LA20_19=='+'||(LA20_19>='-' && LA20_19<='9')||(LA20_19>=';' && LA20_19<='=')||(LA20_19>='?' && LA20_19<='Z')||(LA20_19>='^' && LA20_19<='z')||LA20_19=='|'||(LA20_19>='~' && LA20_19<='\uFFFF')) ) {s = 49;}
-
-                        else if ( (LA20_19=='\t'||LA20_19==' ') ) {s = 42;}
-
-                        else if ( (LA20_19=='*'||LA20_19==':'||LA20_19=='>'||LA20_19=='['||LA20_19==']'||LA20_19=='{'||LA20_19=='}') ) {s = 51;}
-
-                        else if ( (LA20_19==',') ) {s = 52;}
-
-                        else if ( ((LA20_19>='(' && LA20_19<=')')) && ((( isValue() )||( isHead() )))) {s = 36;}
+                        if ( (LA20_100=='\"') ) {s = 89;}
 
-                        else if ( (LA20_19=='#') && ((( isHead() )||( isValue() )))) {s = 38;}
+                        else if ( ((LA20_100>='\u0000' && LA20_100<='\t')||(LA20_100>='\u000B' && LA20_100<='\f')||(LA20_100>='\u000E' && LA20_100<='!')||(LA20_100>='#' && LA20_100<='[')||(LA20_100>=']' && LA20_100<='\uFFFF')) ) {s = 90;}
 
-                        else if ( (LA20_19=='\n'||LA20_19=='\r'||LA20_19=='\"'||LA20_19=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_100=='\\') ) {s = 91;}
 
-                        else s = 50;
+                        else if ( (LA20_100=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_19);
+                        input.seek(index20_100);
                         if ( s>=0 ) return s;
                         break;
                     case 61 : 
-                        int LA20_77 = input.LA(1);
+                        int LA20_70 = input.LA(1);
 
                          
-                        int index20_77 = input.index();
+                        int index20_70 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_77=='\t'||LA20_77==' ') ) {s = 75;}
+                        if ( (LA20_70=='\t'||LA20_70==' ') && ((( isHead() )||( isValue() )))) {s = 69;}
 
-                        else if ( ((LA20_77>='\u0000' && LA20_77<='\b')||(LA20_77>='\u000B' && LA20_77<='\f')||(LA20_77>='\u000E' && LA20_77<='\u001F')||LA20_77=='!'||(LA20_77>='$' && LA20_77<='\'')||LA20_77=='+'||(LA20_77>='-' && LA20_77<='9')||(LA20_77>=';' && LA20_77<='=')||(LA20_77>='?' && LA20_77<='Z')||(LA20_77>='^' && LA20_77<='z')||LA20_77=='|'||(LA20_77>='~' && LA20_77<='\uFFFF')) ) {s = 76;}
+                        else if ( ((LA20_70>='\u0000' && LA20_70<='\b')||(LA20_70>='\u000B' && LA20_70<='\f')||(LA20_70>='\u000E' && LA20_70<='\u001F')||LA20_70=='!'||(LA20_70>='$' && LA20_70<='\'')||LA20_70=='+'||(LA20_70>='-' && LA20_70<='9')||(LA20_70>=';' && LA20_70<='=')||(LA20_70>='?' && LA20_70<='Z')||(LA20_70>='^' && LA20_70<='z')||LA20_70=='|'||(LA20_70>='~' && LA20_70<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 70;}
 
-                        else if ( (LA20_77=='*'||LA20_77==':'||LA20_77=='>'||LA20_77=='['||LA20_77==']'||LA20_77=='{'||LA20_77=='}') ) {s = 77;}
+                        else if ( (LA20_70=='*'||LA20_70==':'||LA20_70=='>'||LA20_70=='['||LA20_70==']'||LA20_70=='{'||LA20_70=='}') && ((( isHead() )||( isValue() )))) {s = 71;}
 
-                        else if ( (LA20_77==',') ) {s = 78;}
+                        else if ( ((LA20_70>='(' && LA20_70<=')')||LA20_70==',') && ((( isHead() )||( isValue() )))) {s = 72;}
 
-                        else if ( (LA20_77=='\n'||LA20_77=='\r'||(LA20_77>='\"' && LA20_77<='#')||(LA20_77>='(' && LA20_77<=')')||LA20_77=='\\') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_70=='\r'||(LA20_70>='\"' && LA20_70<='#')||LA20_70=='\\') && (( isHead() ))) {s = 23;}
 
-                        else s = 74;
+                        else s = 64;
 
                          
-                        input.seek(index20_77);
+                        input.seek(index20_70);
                         if ( s>=0 ) return s;
                         break;
                     case 62 : 
-                        int LA20_26 = input.LA(1);
+                        int LA20_47 = input.LA(1);
 
                          
-                        int index20_26 = input.index();
+                        int index20_47 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (!((( isHead() )))) ) {s = 60;}
+                        if ( (!((( isValue() )))) ) {s = 73;}
 
-                        else if ( (( isHead() )) ) {s = 29;}
+                        else if ( (( isValue() )) ) {s = 58;}
 
                          
-                        input.seek(index20_26);
+                        input.seek(index20_47);
                         if ( s>=0 ) return s;
                         break;
                     case 63 : 
-                        int LA20_25 = input.LA(1);
+                        int LA20_18 = input.LA(1);
 
                          
-                        int index20_25 = input.index();
+                        int index20_18 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (!((( isHead() )))) ) {s = 60;}
+                        if ( ((LA20_18>='\u0000' && LA20_18<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else if ( (( isHead() )) ) {s = 29;}
+                        else s = 48;
 
                          
-                        input.seek(index20_25);
+                        input.seek(index20_18);
                         if ( s>=0 ) return s;
                         break;
                     case 64 : 
-                        int LA20_8 = input.LA(1);
+                        int LA20_13 = input.LA(1);
 
                          
-                        int index20_8 = input.index();
+                        int index20_13 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_8=='\n'||LA20_8=='\r') ) {s = 29;}
-
-                        else if ( (LA20_8=='\t'||LA20_8==' ') ) {s = 30;}
-
-                        else if ( ((LA20_8>='\u0000' && LA20_8<='\b')||(LA20_8>='\u000B' && LA20_8<='\f')||(LA20_8>='\u000E' && LA20_8<='\u001F')||(LA20_8>='!' && LA20_8<='\"')||LA20_8=='$'||(LA20_8>='&' && LA20_8<=',')||(LA20_8>='.' && LA20_8<='?')||(LA20_8>='A' && LA20_8<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_13>='\u0000' && LA20_13<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else s = 28;
+                        else s = 39;
 
                          
-                        input.seek(index20_8);
+                        input.seek(index20_13);
                         if ( s>=0 ) return s;
                         break;
                     case 65 : 
-                        int LA20_59 = input.LA(1);
+                        int LA20_16 = input.LA(1);
 
                          
-                        int index20_59 = input.index();
+                        int index20_16 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (!((( isHead() )))) ) {s = 60;}
+                        if ( (LA20_16=='\t'||LA20_16==' ') ) {s = 42;}
 
-                        else if ( (( isHead() )) ) {s = 29;}
+                        else if ( (LA20_16=='\n'||LA20_16=='\r'||(LA20_16>='\"' && LA20_16<='#')||LA20_16=='\\') && (( isHead() ))) {s = 23;}
+
+                        else if ( ((LA20_16>='\u0000' && LA20_16<='\b')||(LA20_16>='\u000B' && LA20_16<='\f')||(LA20_16>='\u000E' && LA20_16<='\u001F')||LA20_16=='!'||(LA20_16>='$' && LA20_16<='\'')||LA20_16=='+'||(LA20_16>='-' && LA20_16<='9')||(LA20_16>=';' && LA20_16<='=')||(LA20_16>='?' && LA20_16<='Z')||(LA20_16>='^' && LA20_16<='z')||LA20_16=='|'||(LA20_16>='~' && LA20_16<='\uFFFF')) ) {s = 43;}
+
+                        else if ( (LA20_16=='*'||LA20_16==':'||LA20_16=='>'||LA20_16=='['||LA20_16==']'||LA20_16=='{'||LA20_16=='}') ) {s = 44;}
+
+                        else if ( ((LA20_16>='(' && LA20_16<=')')||LA20_16==',') ) {s = 45;}
+
+                        else s = 46;
 
                          
-                        input.seek(index20_59);
+                        input.seek(index20_16);
                         if ( s>=0 ) return s;
                         break;
                     case 66 : 
-                        int LA20_76 = input.LA(1);
+                        int LA20_103 = input.LA(1);
 
                          
-                        int index20_76 = input.index();
+                        int index20_103 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_76=='\t'||LA20_76==' ') ) {s = 75;}
-
-                        else if ( ((LA20_76>='\u0000' && LA20_76<='\b')||(LA20_76>='\u000B' && LA20_76<='\f')||(LA20_76>='\u000E' && LA20_76<='\u001F')||LA20_76=='!'||(LA20_76>='$' && LA20_76<='\'')||LA20_76=='+'||(LA20_76>='-' && LA20_76<='9')||(LA20_76>=';' && LA20_76<='=')||(LA20_76>='?' && LA20_76<='Z')||(LA20_76>='^' && LA20_76<='z')||LA20_76=='|'||(LA20_76>='~' && LA20_76<='\uFFFF')) ) {s = 76;}
-
-                        else if ( (LA20_76=='*'||LA20_76==':'||LA20_76=='>'||LA20_76=='['||LA20_76==']'||LA20_76=='{'||LA20_76=='}') ) {s = 77;}
-
-                        else if ( (LA20_76==',') ) {s = 78;}
-
-                        else if ( (LA20_76=='\n'||LA20_76=='\r'||(LA20_76>='\"' && LA20_76<='#')||(LA20_76>='(' && LA20_76<=')')||LA20_76=='\\') && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_103>='0' && LA20_103<='9')||(LA20_103>='A' && LA20_103<='F')||(LA20_103>='a' && LA20_103<='f')) ) {s = 105;}
 
-                        else s = 74;
+                        else if ( ((LA20_103>='\u0000' && LA20_103<='\t')||(LA20_103>='\u000B' && LA20_103<='/')||(LA20_103>=':' && LA20_103<='@')||(LA20_103>='G' && LA20_103<='`')||(LA20_103>='g' && LA20_103<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_76);
+                        input.seek(index20_103);
                         if ( s>=0 ) return s;
                         break;
                     case 67 : 
-                        int LA20_36 = input.LA(1);
+                        int LA20_38 = input.LA(1);
 
                          
-                        int index20_36 = input.index();
+                        int index20_38 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_36=='\n'||LA20_36=='\r'||(LA20_36>='\"' && LA20_36<='#')||(LA20_36>='(' && LA20_36<=')')||LA20_36=='\\') && (( isHead() ))) {s = 23;}
+                        if ( (LA20_38=='\t'||LA20_38==' ') && ((( isHead() )||( isValue() )))) {s = 69;}
 
-                        else if ( (LA20_36=='\t'||LA20_36==' ') && ((( isHead() )||( isValue() )))) {s = 65;}
+                        else if ( ((LA20_38>='\u0000' && LA20_38<='\b')||(LA20_38>='\u000B' && LA20_38<='\f')||(LA20_38>='\u000E' && LA20_38<='\u001F')||LA20_38=='!'||(LA20_38>='$' && LA20_38<='\'')||LA20_38=='+'||(LA20_38>='-' && LA20_38<='9')||(LA20_38>=';' && LA20_38<='=')||(LA20_38>='?' && LA20_38<='Z')||(LA20_38>='^' && LA20_38<='z')||LA20_38=='|'||(LA20_38>='~' && LA20_38<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 70;}
 
-                        else if ( ((LA20_36>='\u0000' && LA20_36<='\b')||(LA20_36>='\u000B' && LA20_36<='\f')||(LA20_36>='\u000E' && LA20_36<='\u001F')||LA20_36=='!'||(LA20_36>='$' && LA20_36<='\'')||LA20_36=='+'||(LA20_36>='-' && LA20_36<='9')||(LA20_36>=';' && LA20_36<='=')||(LA20_36>='?' && LA20_36<='Z')||(LA20_36>='^' && LA20_36<='z')||LA20_36=='|'||(LA20_36>='~' && LA20_36<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 66;}
+                        else if ( (LA20_38=='*'||LA20_38==':'||LA20_38=='>'||LA20_38=='['||LA20_38==']'||LA20_38=='{'||LA20_38=='}') && ((( isHead() )||( isValue() )))) {s = 71;}
 
-                        else if ( (LA20_36=='*'||LA20_36==':'||LA20_36=='>'||LA20_36=='['||LA20_36==']'||LA20_36=='{'||LA20_36=='}') && ((( isValue() )||( isHead() )))) {s = 67;}
+                        else if ( ((LA20_38>='(' && LA20_38<=')')||LA20_38==',') && ((( isHead() )||( isValue() )))) {s = 72;}
 
-                        else if ( (LA20_36==',') && ((( isHead() )||( isValue() )))) {s = 68;}
+                        else if ( (LA20_38=='\r'||(LA20_38>='\"' && LA20_38<='#')||LA20_38=='\\') && (( isHead() ))) {s = 23;}
 
                         else s = 64;
 
                          
-                        input.seek(index20_36);
+                        input.seek(index20_38);
                         if ( s>=0 ) return s;
                         break;
                     case 68 : 
-                        int LA20_96 = input.LA(1);
+                        int LA20_78 = input.LA(1);
 
                          
-                        int index20_96 = input.index();
+                        int index20_78 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_96=='\"') ) {s = 89;}
+                        if ( (LA20_78=='\t'||LA20_78==' ') ) {s = 75;}
 
-                        else if ( ((LA20_96>='\u0000' && LA20_96<='\t')||(LA20_96>='\u000B' && LA20_96<='\f')||(LA20_96>='\u000E' && LA20_96<='!')||(LA20_96>='#' && LA20_96<='[')||(LA20_96>=']' && LA20_96<='\uFFFF')) ) {s = 90;}
+                        else if ( ((LA20_78>='\u0000' && LA20_78<='\b')||(LA20_78>='\u000B' && LA20_78<='\f')||(LA20_78>='\u000E' && LA20_78<='\u001F')||LA20_78=='!'||(LA20_78>='$' && LA20_78<='\'')||LA20_78=='+'||(LA20_78>='-' && LA20_78<='9')||(LA20_78>=';' && LA20_78<='=')||(LA20_78>='?' && LA20_78<='Z')||(LA20_78>='^' && LA20_78<='z')||LA20_78=='|'||(LA20_78>='~' && LA20_78<='\uFFFF')) ) {s = 76;}
 
-                        else if ( (LA20_96=='\\') ) {s = 91;}
+                        else if ( (LA20_78=='*'||LA20_78==':'||LA20_78=='>'||LA20_78=='['||LA20_78==']'||LA20_78=='{'||LA20_78=='}') ) {s = 77;}
 
-                        else if ( (LA20_96=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( ((LA20_78>='(' && LA20_78<=')')||LA20_78==',') ) {s = 78;}
+
+                        else if ( (LA20_78=='\n'||LA20_78=='\r'||(LA20_78>='\"' && LA20_78<='#')||LA20_78=='\\') && (( isHead() ))) {s = 23;}
+
+                        else s = 74;
 
                          
-                        input.seek(index20_96);
+                        input.seek(index20_78);
                         if ( s>=0 ) return s;
                         break;
                     case 69 : 
-                        int LA20_107 = input.LA(1);
+                        int LA20_19 = input.LA(1);
 
                          
-                        int index20_107 = input.index();
+                        int index20_19 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_107>='0' && LA20_107<='9')||(LA20_107>='A' && LA20_107<='F')||(LA20_107>='a' && LA20_107<='f')) ) {s = 108;}
+                        if ( ((LA20_19>='\u0000' && LA20_19<='\b')||(LA20_19>='\u000B' && LA20_19<='\f')||(LA20_19>='\u000E' && LA20_19<='\u001F')||LA20_19=='!'||(LA20_19>='$' && LA20_19<='\'')||LA20_19=='+'||(LA20_19>='-' && LA20_19<='9')||(LA20_19>=';' && LA20_19<='=')||(LA20_19>='?' && LA20_19<='Z')||(LA20_19>='^' && LA20_19<='z')||LA20_19=='|'||(LA20_19>='~' && LA20_19<='\uFFFF')) ) {s = 49;}
 
-                        else if ( ((LA20_107>='\u0000' && LA20_107<='\t')||(LA20_107>='\u000B' && LA20_107<='/')||(LA20_107>=':' && LA20_107<='@')||(LA20_107>='G' && LA20_107<='`')||(LA20_107>='g' && LA20_107<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_19=='#') && ((( isHead() )||( isValue() )))) {s = 38;}
+
+                        else if ( (LA20_19=='\t'||LA20_19==' ') ) {s = 42;}
+
+                        else if ( (LA20_19=='\n'||LA20_19=='\r'||LA20_19=='\"'||LA20_19=='\\') && (( isHead() ))) {s = 23;}
+
+                        else if ( (LA20_19=='*'||LA20_19==':'||LA20_19=='>'||LA20_19=='['||LA20_19==']'||LA20_19=='{'||LA20_19=='}') ) {s = 51;}
+
+                        else if ( ((LA20_19>='(' && LA20_19<=')')||LA20_19==',') ) {s = 52;}
+
+                        else s = 50;
 
                          
-                        input.seek(index20_107);
+                        input.seek(index20_19);
                         if ( s>=0 ) return s;
                         break;
                     case 70 : 
-                        int LA20_91 = input.LA(1);
+                        int LA20_99 = input.LA(1);
 
                          
-                        int index20_91 = input.index();
+                        int index20_99 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_91=='\"') ) {s = 93;}
-
-                        else if ( (LA20_91=='\\') ) {s = 94;}
-
-                        else if ( (LA20_91=='/') ) {s = 95;}
-
-                        else if ( (LA20_91=='b') ) {s = 96;}
-
-                        else if ( (LA20_91=='f') ) {s = 97;}
-
-                        else if ( (LA20_91=='n') ) {s = 98;}
+                        if ( (LA20_99=='\"') ) {s = 89;}
 
-                        else if ( (LA20_91=='r') ) {s = 99;}
-
-                        else if ( (LA20_91=='t') ) {s = 100;}
+                        else if ( ((LA20_99>='\u0000' && LA20_99<='\t')||(LA20_99>='\u000B' && LA20_99<='\f')||(LA20_99>='\u000E' && LA20_99<='!')||(LA20_99>='#' && LA20_99<='[')||(LA20_99>=']' && LA20_99<='\uFFFF')) ) {s = 90;}
 
-                        else if ( (LA20_91=='u') ) {s = 101;}
+                        else if ( (LA20_99=='\\') ) {s = 91;}
 
-                        else if ( ((LA20_91>='\u0000' && LA20_91<='\t')||(LA20_91>='\u000B' && LA20_91<='!')||(LA20_91>='#' && LA20_91<='.')||(LA20_91>='0' && LA20_91<='[')||(LA20_91>=']' && LA20_91<='a')||(LA20_91>='c' && LA20_91<='e')||(LA20_91>='g' && LA20_91<='m')||(LA20_91>='o' && LA20_91<='q')||LA20_91=='s'||(LA20_91>='v' && LA20_91<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_99=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_91);
+                        input.seek(index20_99);
                         if ( s>=0 ) return s;
                         break;
                     case 71 : 
-                        int LA20_10 = input.LA(1);
+                        int LA20_85 = input.LA(1);
 
                          
-                        int index20_10 = input.index();
+                        int index20_85 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_10>='\u0000' && LA20_10<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( (LA20_85=='\"') ) {s = 55;}
 
-                        else s = 34;
+                        else if ( (LA20_85=='#') ) {s = 56;}
+
+                        else if ( (LA20_85=='\\') ) {s = 54;}
+
+                        else if ( (LA20_85=='\n'||LA20_85=='\r') && (( isHead() ))) {s = 23;}
+
+                        else if ( ((LA20_85>='\u0000' && LA20_85<='\t')||(LA20_85>='\u000B' && LA20_85<='\f')||(LA20_85>='\u000E' && LA20_85<='!')||(LA20_85>='$' && LA20_85<='[')||(LA20_85>=']' && LA20_85<='\uFFFF')) ) {s = 53;}
 
                          
-                        input.seek(index20_10);
+                        input.seek(index20_85);
                         if ( s>=0 ) return s;
                         break;
                     case 72 : 
-                        int LA20_97 = input.LA(1);
+                        int LA20_26 = input.LA(1);
 
                          
-                        int index20_97 = input.index();
+                        int index20_26 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_97=='\"') ) {s = 89;}
-
-                        else if ( ((LA20_97>='\u0000' && LA20_97<='\t')||(LA20_97>='\u000B' && LA20_97<='\f')||(LA20_97>='\u000E' && LA20_97<='!')||(LA20_97>='#' && LA20_97<='[')||(LA20_97>=']' && LA20_97<='\uFFFF')) ) {s = 90;}
-
-                        else if ( (LA20_97=='\\') ) {s = 91;}
+                        if ( (!((( isHead() )))) ) {s = 60;}
 
-                        else if ( (LA20_97=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( (( isHead() )) ) {s = 28;}
 
                          
-                        input.seek(index20_97);
+                        input.seek(index20_26);
                         if ( s>=0 ) return s;
                         break;
                     case 73 : 
-                        int LA20_0 = input.LA(1);
+                        int LA20_25 = input.LA(1);
 
                          
-                        int index20_0 = input.index();
+                        int index20_25 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_0=='#') ) {s = 1;}
-
-                        else if ( (LA20_0=='%') ) {s = 2;}
-
-                        else if ( (LA20_0=='\r') ) {s = 3;}
-
-                        else if ( (LA20_0=='\n') ) {s = 4;}
-
-                        else if ( (LA20_0==' ') ) {s = 5;}
-
-                        else if ( (LA20_0=='-') ) {s = 6;}
-
-                        else if ( (LA20_0=='@') ) {s = 7;}
-
-                        else if ( (LA20_0=='\t') ) {s = 8;}
-
-                        else if ( (LA20_0=='(') ) {s = 9;}
-
-                        else if ( (LA20_0==')') ) {s = 10;}
-
-                        else if ( (LA20_0==',') ) {s = 11;}
-
-                        else if ( (LA20_0==':') ) {s = 12;}
-
-                        else if ( (LA20_0=='>') ) {s = 13;}
-
-                        else if ( (LA20_0=='|') ) {s = 14;}
-
-                        else if ( (LA20_0=='*') ) {s = 15;}
-
-                        else if ( (LA20_0=='+') ) {s = 16;}
-
-                        else if ( (LA20_0=='[') ) {s = 17;}
-
-                        else if ( (LA20_0==']') ) {s = 18;}
-
-                        else if ( (LA20_0=='?') ) {s = 19;}
-
-                        else if ( (LA20_0=='\"') ) {s = 20;}
-
-                        else if ( ((LA20_0>='\u0000' && LA20_0<='\b')||(LA20_0>='\u000B' && LA20_0<='\f')||(LA20_0>='\u000E' && LA20_0<='\u001F')||LA20_0=='!'||LA20_0=='$'||LA20_0=='&'||(LA20_0>='.' && LA20_0<='9')||(LA20_0>=';' && LA20_0<='=')||(LA20_0>='A' && LA20_0<='Z')||(LA20_0>='^' && LA20_0<='z')||(LA20_0>='~' && LA20_0<='\uFFFF')) ) {s = 21;}
-
-                        else if ( (LA20_0=='{') && ((( isValue() )||( isHead() )))) {s = 22;}
+                        if ( (!((( isHead() )))) ) {s = 60;}
 
-                        else if ( (LA20_0=='\''||LA20_0=='\\'||LA20_0=='}') && (( isHead() ))) {s = 23;}
+                        else if ( (( isHead() )) ) {s = 28;}
 
                          
-                        input.seek(index20_0);
+                        input.seek(index20_25);
                         if ( s>=0 ) return s;
                         break;
                     case 74 : 
-                        int LA20_13 = input.LA(1);
+                        int LA20_15 = input.LA(1);
 
                          
-                        int index20_13 = input.index();
+                        int index20_15 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( ((LA20_13>='\u0000' && LA20_13<='\uFFFF')) && (( isHead() ))) {s = 23;}
+                        if ( (LA20_15=='\t'||LA20_15==' ') ) {s = 42;}
 
-                        else s = 39;
+                        else if ( (LA20_15=='\n'||LA20_15=='\r'||(LA20_15>='\"' && LA20_15<='#')||LA20_15=='\\') && (( isHead() ))) {s = 23;}
+
+                        else if ( ((LA20_15>='\u0000' && LA20_15<='\b')||(LA20_15>='\u000B' && LA20_15<='\f')||(LA20_15>='\u000E' && LA20_15<='\u001F')||LA20_15=='!'||(LA20_15>='$' && LA20_15<='\'')||LA20_15=='+'||(LA20_15>='-' && LA20_15<='9')||(LA20_15>=';' && LA20_15<='=')||(LA20_15>='?' && LA20_15<='Z')||(LA20_15>='^' && LA20_15<='z')||LA20_15=='|'||(LA20_15>='~' && LA20_15<='\uFFFF')) ) {s = 43;}
+
+                        else if ( (LA20_15=='*'||LA20_15==':'||LA20_15=='>'||LA20_15=='['||LA20_15==']'||LA20_15=='{'||LA20_15=='}') ) {s = 44;}
+
+                        else if ( ((LA20_15>='(' && LA20_15<=')')||LA20_15==',') ) {s = 45;}
+
+                        else s = 41;
 
                          
-                        input.seek(index20_13);
+                        input.seek(index20_15);
                         if ( s>=0 ) return s;
                         break;
                     case 75 : 
-                        int LA20_81 = input.LA(1);
+                        int LA20_17 = input.LA(1);
 
                          
-                        int index20_81 = input.index();
+                        int index20_17 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_81=='\"') ) {s = 55;}
-
-                        else if ( (LA20_81=='#') ) {s = 56;}
-
-                        else if ( (LA20_81=='\\') ) {s = 54;}
-
-                        else if ( (LA20_81=='\n'||LA20_81=='\r') && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_17>='\u0000' && LA20_17<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
-                        else if ( ((LA20_81>='\u0000' && LA20_81<='\t')||(LA20_81>='\u000B' && LA20_81<='\f')||(LA20_81>='\u000E' && LA20_81<='!')||(LA20_81>='$' && LA20_81<='[')||(LA20_81>=']' && LA20_81<='\uFFFF')) ) {s = 53;}
+                        else s = 47;
 
                          
-                        input.seek(index20_81);
+                        input.seek(index20_17);
                         if ( s>=0 ) return s;
                         break;
                     case 76 : 
-                        int LA20_98 = input.LA(1);
+                        int LA20_59 = input.LA(1);
 
                          
-                        int index20_98 = input.index();
+                        int index20_59 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_98=='\"') ) {s = 89;}
-
-                        else if ( ((LA20_98>='\u0000' && LA20_98<='\t')||(LA20_98>='\u000B' && LA20_98<='\f')||(LA20_98>='\u000E' && LA20_98<='!')||(LA20_98>='#' && LA20_98<='[')||(LA20_98>=']' && LA20_98<='\uFFFF')) ) {s = 90;}
-
-                        else if ( (LA20_98=='\\') ) {s = 91;}
+                        if ( (!((( isHead() )))) ) {s = 60;}
 
-                        else if ( (LA20_98=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( (( isHead() )) ) {s = 28;}
 
                          
-                        input.seek(index20_98);
+                        input.seek(index20_59);
                         if ( s>=0 ) return s;
                         break;
                     case 77 : 
-                        int LA20_86 = input.LA(1);
+                        int LA20_108 = input.LA(1);
 
                          
-                        int index20_86 = input.index();
+                        int index20_108 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_86=='\"') ) {s = 55;}
-
-                        else if ( (LA20_86=='#') ) {s = 56;}
+                        if ( (LA20_108=='\"') ) {s = 89;}
 
-                        else if ( (LA20_86=='\\') ) {s = 54;}
+                        else if ( ((LA20_108>='\u0000' && LA20_108<='\t')||(LA20_108>='\u000B' && LA20_108<='\f')||(LA20_108>='\u000E' && LA20_108<='!')||(LA20_108>='#' && LA20_108<='[')||(LA20_108>=']' && LA20_108<='\uFFFF')) ) {s = 90;}
 
-                        else if ( (LA20_86=='\n'||LA20_86=='\r') && (( isHead() ))) {s = 23;}
+                        else if ( (LA20_108=='\\') ) {s = 91;}
 
-                        else if ( ((LA20_86>='\u0000' && LA20_86<='\t')||(LA20_86>='\u000B' && LA20_86<='\f')||(LA20_86>='\u000E' && LA20_86<='!')||(LA20_86>='$' && LA20_86<='[')||(LA20_86>=']' && LA20_86<='\uFFFF')) ) {s = 53;}
+                        else if ( (LA20_108=='\r') && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_86);
+                        input.seek(index20_108);
                         if ( s>=0 ) return s;
                         break;
                     case 78 : 
-                        int LA20_70 = input.LA(1);
+                        int LA20_107 = input.LA(1);
 
                          
-                        int index20_70 = input.index();
+                        int index20_107 = input.index();
                         input.rewind();
                         s = -1;
-                        if ( (LA20_70=='\t'||LA20_70==' ') && ((( isHead() )||( isValue() )))) {s = 69;}
-
-                        else if ( ((LA20_70>='\u0000' && LA20_70<='\b')||(LA20_70>='\u000B' && LA20_70<='\f')||(LA20_70>='\u000E' && LA20_70<='\u001F')||LA20_70=='!'||(LA20_70>='$' && LA20_70<='\'')||LA20_70=='+'||(LA20_70>='-' && LA20_70<='9')||(LA20_70>=';' && LA20_70<='=')||(LA20_70>='?' && LA20_70<='Z')||(LA20_70>='^' && LA20_70<='z')||LA20_70=='|'||(LA20_70>='~' && LA20_70<='\uFFFF')) && ((( isHead() )||( isValue() )))) {s = 70;}
-
-                        else if ( (LA20_70=='*'||LA20_70==':'||LA20_70=='>'||LA20_70=='['||LA20_70==']'||LA20_70=='{'||LA20_70=='}') && ((( isHead() )||( isValue() )))) {s = 71;}
-
-                        else if ( (LA20_70==',') && ((( isHead() )||( isValue() )))) {s = 72;}
-
-                        else if ( (LA20_70=='\r'||(LA20_70>='\"' && LA20_70<='#')||(LA20_70>='(' && LA20_70<=')')||LA20_70=='\\') && (( isHead() ))) {s = 23;}
+                        if ( ((LA20_107>='0' && LA20_107<='9')||(LA20_107>='A' && LA20_107<='F')||(LA20_107>='a' && LA20_107<='f')) ) {s = 108;}
 
-                        else s = 64;
+                        else if ( ((LA20_107>='\u0000' && LA20_107<='\t')||(LA20_107>='\u000B' && LA20_107<='/')||(LA20_107>=':' && LA20_107<='@')||(LA20_107>='G' && LA20_107<='`')||(LA20_107>='g' && LA20_107<='\uFFFF')) && (( isHead() ))) {s = 23;}
 
                          
-                        input.seek(index20_70);
+                        input.seek(index20_107);
                         if ( s>=0 ) return s;
                         break;
             }
diff --git a/src/main/java/org/xerial/silk/impl/SilkLexerState.java b/src/main/java/org/xerial/silk/impl/SilkLexerState.java
index 44f9c0d..dbe1bfc 100644
--- a/src/main/java/org/xerial/silk/impl/SilkLexerState.java
+++ b/src/main/java/org/xerial/silk/impl/SilkLexerState.java
@@ -24,6 +24,8 @@
 //--------------------------------------
 package org.xerial.silk.impl;
 
+import org.xerial.util.ArrayDeque;
+import org.xerial.util.Deque;
 import org.xerial.util.graph.Automaton;
 import org.xerial.util.graph.AutomatonCursor;
 
@@ -45,14 +47,16 @@ import org.xerial.util.graph.AutomatonCursor;
 public class SilkLexerState
 {
     public static enum State {
-        INIT, OUT_KEY, OUT_VALUE, IN_VALUE, IN_KEY
+        INIT, OUT_KEY, OUT_VALUE, IN_VALUE, IN_KEY, IN_FUNC_NAME
     };
 
     public static enum Symbol {
-        NodeStart, Colon, EnterParen, LeaveValue
+        NodeStart, Colon, EnterParen, LeaveParen, LeaveValue, At
     }
 
     private static final Automaton<State, Symbol> automaton = new Automaton<State, Symbol>();
+    private Deque<State> stateStack = new ArrayDeque<State>();
+
     //private State beforeJSONState = State.INIT;
     //private int nestLevel = 0;
     private final AutomatonCursor<State, Symbol> cursor;
@@ -60,14 +64,12 @@ public class SilkLexerState
     static
     {
         automaton.addTransition(State.INIT, Symbol.NodeStart, State.OUT_KEY);
-        automaton.addTransition(State.OUT_KEY, Symbol.Colon, State.OUT_VALUE);
         automaton.addTransition(State.OUT_KEY, Symbol.EnterParen, State.IN_KEY);
-        automaton.addTransition(State.OUT_VALUE, Symbol.EnterParen, State.IN_KEY);
+        automaton.addTransition(State.OUT_KEY, Symbol.Colon, State.OUT_VALUE);
+        //automaton.addTransition(State.OUT_VALUE, Symbol.EnterParen, State.IN_KEY);
         automaton.addTransition(State.IN_KEY, Symbol.Colon, State.IN_VALUE);
         automaton.addTransition(State.IN_VALUE, Symbol.LeaveValue, State.IN_KEY);
-
-        //automaton.addTransition(State.IN_VALUE, Symbol.EnterJSONFragment, State.JSON);
-        //automaton.addTransition(State.OUT_VALUE, Symbol.EnterJSONFragment, State.JSON);
+        automaton.addTransition(State.IN_VALUE, Symbol.EnterParen, State.IN_KEY);
 
         for (State each : State.values())
             automaton.addStarTransition(each, each);
@@ -80,32 +82,25 @@ public class SilkLexerState
 
     public State transit(Symbol input)
     {
-        //
-        //        State current = getCurrentState();
-        //        if (current == State.JSON)
-        //        {
-        //            switch (input)
-        //            {
-        //            case EnterJSONFragment:
-        //                nestLevel++;
-        //                break;
-        //            case LeaveJSONFragment:
-        //                nestLevel--;
-        //                if (nestLevel <= 0)
-        //                {
-        //                    cursor.reset(beforeJSONState);
-        //                    return getCurrentState();
-        //                }
-        //                break;
-        //            }
-        //        }
-        //        else
-        //        {
-        //            if (input == Symbol.EnterJSONFragment)
-        //            {
-        //                beforeJSONState = current;
-        //            }
-        //        }
+        State current = getCurrentState();
+        switch (input)
+        {
+        case EnterParen:
+            if (current != State.OUT_VALUE)
+                stateStack.addLast(current);
+            break;
+        case LeaveParen:
+            if (current != State.OUT_VALUE)
+            {
+                if (!stateStack.isEmpty())
+                {
+                    State prevState = stateStack.removeLast();
+                    cursor.reset(prevState);
+                    return prevState;
+                }
+            }
+            break;
+        }
 
         return cursor.transit(input);
     }
diff --git a/src/main/java/org/xerial/silk/impl/SilkParser.java b/src/main/java/org/xerial/silk/impl/SilkParser.java
index 0da5734..bf52594 100644
--- a/src/main/java/org/xerial/silk/impl/SilkParser.java
+++ b/src/main/java/org/xerial/silk/impl/SilkParser.java
@@ -1,4 +1,4 @@
-// $ANTLR 3.1.1 F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g 2009-02-16 16:30:51
+// $ANTLR 3.1.1 c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g 2009-02-18 00:23:19
 
 /*--------------------------------------------------------------------------
  *  Copyright 2009 Taro L. Saito
@@ -115,7 +115,7 @@ public class SilkParser extends Parser {
     }
 
     public String[] getTokenNames() { return SilkParser.tokenNames; }
-    public String getGrammarFileName() { return "F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g"; }
+    public String getGrammarFileName() { return "c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g"; }
 
 
     public static class silkFile_return extends ParserRuleReturnScope {
@@ -124,7 +124,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "silkFile"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:244:1: silkFile : ( silkLine )* -> ^( Silk ( silkLine )* ) ;
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:243:1: silkFile : ( silkLine )* -> ^( Silk ( silkLine )* ) ;
     public final SilkParser.silkFile_return silkFile() throws RecognitionException {
         SilkParser.silkFile_return retval = new SilkParser.silkFile_return();
         retval.start = input.LT(1);
@@ -136,10 +136,10 @@ public class SilkParser extends Parser {
 
         RewriteRuleSubtreeStream stream_silkLine=new RewriteRuleSubtreeStream(adaptor,"rule silkLine");
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:244:9: ( ( silkLine )* -> ^( Silk ( silkLine )* ) )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:244:11: ( silkLine )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:243:9: ( ( silkLine )* -> ^( Silk ( silkLine )* ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:243:11: ( silkLine )*
             {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:244:11: ( silkLine )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:243:11: ( silkLine )*
             loop1:
             do {
                 int alt1=2;
@@ -152,9 +152,9 @@ public class SilkParser extends Parser {
 
                 switch (alt1) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:244:11: silkLine
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:243:11: silkLine
             	    {
-            	    pushFollow(FOLLOW_silkLine_in_silkFile946);
+            	    pushFollow(FOLLOW_silkLine_in_silkFile956);
             	    silkLine1=silkLine();
 
             	    state._fsp--;
@@ -181,14 +181,14 @@ public class SilkParser extends Parser {
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
             root_0 = (Object)adaptor.nil();
-            // 244:21: -> ^( Silk ( silkLine )* )
+            // 243:21: -> ^( Silk ( silkLine )* )
             {
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:244:24: ^( Silk ( silkLine )* )
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:243:24: ^( Silk ( silkLine )* )
                 {
                 Object root_1 = (Object)adaptor.nil();
                 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(Silk, "Silk"), root_1);
 
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:244:31: ( silkLine )*
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:243:31: ( silkLine )*
                 while ( stream_silkLine.hasNext() ) {
                     adaptor.addChild(root_1, stream_silkLine.nextTree());
 
@@ -227,7 +227,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "silkLine"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:247:1: silkLine : ( NodeIndent nodeItem -> ^( SilkNode NodeIndent nodeItem ) | function | Preamble | DataLine | BlankLine | WhiteSpace -> BlankLine );
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:246:1: silkLine : ( NodeIndent nodeItem -> ^( SilkNode NodeIndent nodeItem ) | function | Preamble | DataLine | BlankLine | WhiteSpace -> BlankLine );
     public final SilkParser.silkLine_return silkLine() throws RecognitionException {
         SilkParser.silkLine_return retval = new SilkParser.silkLine_return();
         retval.start = input.LT(1);
@@ -253,7 +253,7 @@ public class SilkParser extends Parser {
         RewriteRuleTokenStream stream_NodeIndent=new RewriteRuleTokenStream(adaptor,"token NodeIndent");
         RewriteRuleSubtreeStream stream_nodeItem=new RewriteRuleSubtreeStream(adaptor,"rule nodeItem");
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:248:2: ( NodeIndent nodeItem -> ^( SilkNode NodeIndent nodeItem ) | function | Preamble | DataLine | BlankLine | WhiteSpace -> BlankLine )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:247:2: ( NodeIndent nodeItem -> ^( SilkNode NodeIndent nodeItem ) | function | Preamble | DataLine | BlankLine | WhiteSpace -> BlankLine )
             int alt2=6;
             switch ( input.LA(1) ) {
             case NodeIndent:
@@ -308,12 +308,12 @@ public class SilkParser extends Parser {
 
             switch (alt2) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:248:4: NodeIndent nodeItem
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:247:4: NodeIndent nodeItem
                     {
-                    NodeIndent2=(Token)match(input,NodeIndent,FOLLOW_NodeIndent_in_silkLine967);  
+                    NodeIndent2=(Token)match(input,NodeIndent,FOLLOW_NodeIndent_in_silkLine977);  
                     stream_NodeIndent.add(NodeIndent2);
 
-                    pushFollow(FOLLOW_nodeItem_in_silkLine969);
+                    pushFollow(FOLLOW_nodeItem_in_silkLine979);
                     nodeItem3=nodeItem();
 
                     state._fsp--;
@@ -331,9 +331,9 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 248:24: -> ^( SilkNode NodeIndent nodeItem )
+                    // 247:24: -> ^( SilkNode NodeIndent nodeItem )
                     {
-                        // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:248:27: ^( SilkNode NodeIndent nodeItem )
+                        // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:247:27: ^( SilkNode NodeIndent nodeItem )
                         {
                         Object root_1 = (Object)adaptor.nil();
                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(SilkNode, "SilkNode"), root_1);
@@ -350,11 +350,11 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:249:4: function
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:248:4: function
                     {
                     root_0 = (Object)adaptor.nil();
 
-                    pushFollow(FOLLOW_function_in_silkLine985);
+                    pushFollow(FOLLOW_function_in_silkLine995);
                     function4=function();
 
                     state._fsp--;
@@ -364,11 +364,11 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 3 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:250:4: Preamble
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:249:4: Preamble
                     {
                     root_0 = (Object)adaptor.nil();
 
-                    Preamble5=(Token)match(input,Preamble,FOLLOW_Preamble_in_silkLine990); 
+                    Preamble5=(Token)match(input,Preamble,FOLLOW_Preamble_in_silkLine1000); 
                     Preamble5_tree = (Object)adaptor.create(Preamble5);
                     adaptor.addChild(root_0, Preamble5_tree);
 
@@ -376,11 +376,11 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 4 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:251:4: DataLine
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:250:4: DataLine
                     {
                     root_0 = (Object)adaptor.nil();
 
-                    DataLine6=(Token)match(input,DataLine,FOLLOW_DataLine_in_silkLine995); 
+                    DataLine6=(Token)match(input,DataLine,FOLLOW_DataLine_in_silkLine1005); 
                     DataLine6_tree = (Object)adaptor.create(DataLine6);
                     adaptor.addChild(root_0, DataLine6_tree);
 
@@ -388,11 +388,11 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 5 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:252:4: BlankLine
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:251:4: BlankLine
                     {
                     root_0 = (Object)adaptor.nil();
 
-                    BlankLine7=(Token)match(input,BlankLine,FOLLOW_BlankLine_in_silkLine1000); 
+                    BlankLine7=(Token)match(input,BlankLine,FOLLOW_BlankLine_in_silkLine1010); 
                     BlankLine7_tree = (Object)adaptor.create(BlankLine7);
                     adaptor.addChild(root_0, BlankLine7_tree);
 
@@ -400,9 +400,9 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 6 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:253:4: WhiteSpace
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:252:4: WhiteSpace
                     {
-                    WhiteSpace8=(Token)match(input,WhiteSpace,FOLLOW_WhiteSpace_in_silkLine1005);  
+                    WhiteSpace8=(Token)match(input,WhiteSpace,FOLLOW_WhiteSpace_in_silkLine1015);  
                     stream_WhiteSpace.add(WhiteSpace8);
 
 
@@ -417,7 +417,7 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 253:15: -> BlankLine
+                    // 252:15: -> BlankLine
                     {
                         adaptor.addChild(root_0, (Object)adaptor.create(BlankLine, "BlankLine"));
 
@@ -452,7 +452,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "nodeName"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:257:1: nodeName : ( PlainOneLine | String );
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:256:1: nodeName : ( PlainOneLine | String );
     public final SilkParser.nodeName_return nodeName() throws RecognitionException {
         SilkParser.nodeName_return retval = new SilkParser.nodeName_return();
         retval.start = input.LT(1);
@@ -464,8 +464,8 @@ public class SilkParser extends Parser {
         Object set9_tree=null;
 
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:257:9: ( PlainOneLine | String )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:256:9: ( PlainOneLine | String )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
             {
             root_0 = (Object)adaptor.nil();
 
@@ -507,7 +507,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "nodeValue"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:258:1: nodeValue : ( function_i -> ^( Function function_i ) | ( PlainOneLine | String ) -> Value[$nodeValue.text] | JSON );
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:257:1: nodeValue : ( function_i -> ^( Function function_i ) | ( PlainOneLine | String ) -> Value[$nodeValue.text] | JSON );
     public final SilkParser.nodeValue_return nodeValue() throws RecognitionException {
         SilkParser.nodeValue_return retval = new SilkParser.nodeValue_return();
         retval.start = input.LT(1);
@@ -527,7 +527,7 @@ public class SilkParser extends Parser {
         RewriteRuleTokenStream stream_PlainOneLine=new RewriteRuleTokenStream(adaptor,"token PlainOneLine");
         RewriteRuleSubtreeStream stream_function_i=new RewriteRuleSubtreeStream(adaptor,"rule function_i");
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:259:2: ( function_i -> ^( Function function_i ) | ( PlainOneLine | String ) -> Value[$nodeValue.text] | JSON )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:258:2: ( function_i -> ^( Function function_i ) | ( PlainOneLine | String ) -> Value[$nodeValue.text] | JSON )
             int alt4=3;
             switch ( input.LA(1) ) {
             case At:
@@ -555,9 +555,9 @@ public class SilkParser extends Parser {
 
             switch (alt4) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:259:4: function_i
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:258:4: function_i
                     {
-                    pushFollow(FOLLOW_function_i_in_nodeValue1031);
+                    pushFollow(FOLLOW_function_i_in_nodeValue1041);
                     function_i10=function_i();
 
                     state._fsp--;
@@ -575,9 +575,9 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 259:15: -> ^( Function function_i )
+                    // 258:15: -> ^( Function function_i )
                     {
-                        // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:259:18: ^( Function function_i )
+                        // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:258:18: ^( Function function_i )
                         {
                         Object root_1 = (Object)adaptor.nil();
                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(Function, "Function"), root_1);
@@ -593,9 +593,9 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:260:4: ( PlainOneLine | String )
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:259:4: ( PlainOneLine | String )
                     {
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:260:4: ( PlainOneLine | String )
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:259:4: ( PlainOneLine | String )
                     int alt3=2;
                     int LA3_0 = input.LA(1);
 
@@ -613,18 +613,18 @@ public class SilkParser extends Parser {
                     }
                     switch (alt3) {
                         case 1 :
-                            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:260:5: PlainOneLine
+                            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:259:5: PlainOneLine
                             {
-                            PlainOneLine11=(Token)match(input,PlainOneLine,FOLLOW_PlainOneLine_in_nodeValue1045);  
+                            PlainOneLine11=(Token)match(input,PlainOneLine,FOLLOW_PlainOneLine_in_nodeValue1055);  
                             stream_PlainOneLine.add(PlainOneLine11);
 
 
                             }
                             break;
                         case 2 :
-                            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:260:20: String
+                            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:259:20: String
                             {
-                            String12=(Token)match(input,String,FOLLOW_String_in_nodeValue1049);  
+                            String12=(Token)match(input,String,FOLLOW_String_in_nodeValue1059);  
                             stream_String.add(String12);
 
 
@@ -645,7 +645,7 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 260:28: -> Value[$nodeValue.text]
+                    // 259:28: -> Value[$nodeValue.text]
                     {
                         adaptor.addChild(root_0, (Object)adaptor.create(Value, input.toString(retval.start,input.LT(-1))));
 
@@ -655,11 +655,11 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 3 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:261:4: JSON
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:260:4: JSON
                     {
                     root_0 = (Object)adaptor.nil();
 
-                    JSON13=(Token)match(input,JSON,FOLLOW_JSON_in_nodeValue1060); 
+                    JSON13=(Token)match(input,JSON,FOLLOW_JSON_in_nodeValue1070); 
                     JSON13_tree = (Object)adaptor.create(JSON13);
                     adaptor.addChild(root_0, JSON13_tree);
 
@@ -692,30 +692,30 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "nodeItem"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:1: nodeItem : nodeName ( dataType )? ( Colon nodeValue )? ( LParen attributeList RParen )? ( plural )? -> Name[$nodeName.text] ( nodeValue )? ( dataType )? ( plural )? ( attributeList )? ;
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:263:1: nodeItem : nodeName ( dataType )? ( LParen attributeList RParen )? ( plural )? ( Colon nodeValue )? -> Name[$nodeName.text.trim()] ( nodeValue )? ( dataType )? ( plural )? ( attributeList )? ;
     public final SilkParser.nodeItem_return nodeItem() throws RecognitionException {
         SilkParser.nodeItem_return retval = new SilkParser.nodeItem_return();
         retval.start = input.LT(1);
 
         Object root_0 = null;
 
-        Token Colon16=null;
-        Token LParen18=null;
-        Token RParen20=null;
+        Token LParen16=null;
+        Token RParen18=null;
+        Token Colon20=null;
         SilkParser.nodeName_return nodeName14 = null;
 
         SilkParser.dataType_return dataType15 = null;
 
-        SilkParser.nodeValue_return nodeValue17 = null;
+        SilkParser.attributeList_return attributeList17 = null;
 
-        SilkParser.attributeList_return attributeList19 = null;
+        SilkParser.plural_return plural19 = null;
 
-        SilkParser.plural_return plural21 = null;
+        SilkParser.nodeValue_return nodeValue21 = null;
 
 
-        Object Colon16_tree=null;
-        Object LParen18_tree=null;
-        Object RParen20_tree=null;
+        Object LParen16_tree=null;
+        Object RParen18_tree=null;
+        Object Colon20_tree=null;
         RewriteRuleTokenStream stream_RParen=new RewriteRuleTokenStream(adaptor,"token RParen");
         RewriteRuleTokenStream stream_Colon=new RewriteRuleTokenStream(adaptor,"token Colon");
         RewriteRuleTokenStream stream_LParen=new RewriteRuleTokenStream(adaptor,"token LParen");
@@ -725,27 +725,23 @@ public class SilkParser extends Parser {
         RewriteRuleSubtreeStream stream_plural=new RewriteRuleSubtreeStream(adaptor,"rule plural");
         RewriteRuleSubtreeStream stream_nodeValue=new RewriteRuleSubtreeStream(adaptor,"rule nodeValue");
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:9: ( nodeName ( dataType )? ( Colon nodeValue )? ( LParen attributeList RParen )? ( plural )? -> Name[$nodeName.text] ( nodeValue )? ( dataType )? ( plural )? ( attributeList )? )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:11: nodeName ( dataType )? ( Colon nodeValue )? ( LParen attributeList RParen )? ( plural )?
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:263:9: ( nodeName ( dataType )? ( LParen attributeList RParen )? ( plural )? ( Colon nodeValue )? -> Name[$nodeName.text.trim()] ( nodeValue )? ( dataType )? ( plural )? ( attributeList )? )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:263:11: nodeName ( dataType )? ( LParen attributeList RParen )? ( plural )? ( Colon nodeValue )?
             {
-            pushFollow(FOLLOW_nodeName_in_nodeItem1071);
+            pushFollow(FOLLOW_nodeName_in_nodeItem1081);
             nodeName14=nodeName();
 
             state._fsp--;
 
             stream_nodeName.add(nodeName14.getTree());
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:20: ( dataType )?
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:263:20: ( dataType )?
             int alt5=2;
-            int LA5_0 = input.LA(1);
-
-            if ( (LA5_0==LBracket) ) {
-                alt5=1;
-            }
+            alt5 = dfa5.predict(input);
             switch (alt5) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:20: dataType
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:263:20: dataType
                     {
-                    pushFollow(FOLLOW_dataType_in_nodeItem1073);
+                    pushFollow(FOLLOW_dataType_in_nodeItem1083);
                     dataType15=dataType();
 
                     state._fsp--;
@@ -757,78 +753,66 @@ public class SilkParser extends Parser {
 
             }
 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:30: ( Colon nodeValue )?
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:263:30: ( LParen attributeList RParen )?
             int alt6=2;
-            int LA6_0 = input.LA(1);
-
-            if ( (LA6_0==Colon) ) {
-                alt6=1;
-            }
+            alt6 = dfa6.predict(input);
             switch (alt6) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:31: Colon nodeValue
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:263:31: LParen attributeList RParen
                     {
-                    Colon16=(Token)match(input,Colon,FOLLOW_Colon_in_nodeItem1077);  
-                    stream_Colon.add(Colon16);
+                    LParen16=(Token)match(input,LParen,FOLLOW_LParen_in_nodeItem1087);  
+                    stream_LParen.add(LParen16);
 
-                    pushFollow(FOLLOW_nodeValue_in_nodeItem1079);
-                    nodeValue17=nodeValue();
+                    pushFollow(FOLLOW_attributeList_in_nodeItem1089);
+                    attributeList17=attributeList();
 
                     state._fsp--;
 
-                    stream_nodeValue.add(nodeValue17.getTree());
+                    stream_attributeList.add(attributeList17.getTree());
+                    RParen18=(Token)match(input,RParen,FOLLOW_RParen_in_nodeItem1091);  
+                    stream_RParen.add(RParen18);
+
 
                     }
                     break;
 
             }
 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:49: ( LParen attributeList RParen )?
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:263:61: ( plural )?
             int alt7=2;
-            int LA7_0 = input.LA(1);
-
-            if ( (LA7_0==LParen) ) {
-                alt7=1;
-            }
+            alt7 = dfa7.predict(input);
             switch (alt7) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:50: LParen attributeList RParen
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:263:61: plural
                     {
-                    LParen18=(Token)match(input,LParen,FOLLOW_LParen_in_nodeItem1084);  
-                    stream_LParen.add(LParen18);
-
-                    pushFollow(FOLLOW_attributeList_in_nodeItem1086);
-                    attributeList19=attributeList();
+                    pushFollow(FOLLOW_plural_in_nodeItem1095);
+                    plural19=plural();
 
                     state._fsp--;
 
-                    stream_attributeList.add(attributeList19.getTree());
-                    RParen20=(Token)match(input,RParen,FOLLOW_RParen_in_nodeItem1088);  
-                    stream_RParen.add(RParen20);
-
+                    stream_plural.add(plural19.getTree());
 
                     }
                     break;
 
             }
 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:81: ( plural )?
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:263:69: ( Colon nodeValue )?
             int alt8=2;
-            int LA8_0 = input.LA(1);
-
-            if ( ((LA8_0>=Seq && LA8_0<=Star)||LA8_0==Plus||LA8_0==Question) ) {
-                alt8=1;
-            }
+            alt8 = dfa8.predict(input);
             switch (alt8) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:81: plural
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:263:70: Colon nodeValue
                     {
-                    pushFollow(FOLLOW_plural_in_nodeItem1093);
-                    plural21=plural();
+                    Colon20=(Token)match(input,Colon,FOLLOW_Colon_in_nodeItem1099);  
+                    stream_Colon.add(Colon20);
+
+                    pushFollow(FOLLOW_nodeValue_in_nodeItem1101);
+                    nodeValue21=nodeValue();
 
                     state._fsp--;
 
-                    stream_plural.add(plural21.getTree());
+                    stream_nodeValue.add(nodeValue21.getTree());
 
                     }
                     break;
@@ -838,7 +822,7 @@ public class SilkParser extends Parser {
 
 
             // AST REWRITE
-            // elements: attributeList, plural, nodeValue, dataType
+            // elements: plural, dataType, attributeList, nodeValue
             // token labels: 
             // rule labels: retval
             // token list labels: 
@@ -847,28 +831,28 @@ public class SilkParser extends Parser {
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
             root_0 = (Object)adaptor.nil();
-            // 265:2: -> Name[$nodeName.text] ( nodeValue )? ( dataType )? ( plural )? ( attributeList )?
+            // 264:2: -> Name[$nodeName.text.trim()] ( nodeValue )? ( dataType )? ( plural )? ( attributeList )?
             {
-                adaptor.addChild(root_0, (Object)adaptor.create(Name, (nodeName14!=null?input.toString(nodeName14.start,nodeName14.stop):null)));
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:265:26: ( nodeValue )?
+                adaptor.addChild(root_0, (Object)adaptor.create(Name, (nodeName14!=null?input.toString(nodeName14.start,nodeName14.stop):null).trim()));
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:33: ( nodeValue )?
                 if ( stream_nodeValue.hasNext() ) {
                     adaptor.addChild(root_0, stream_nodeValue.nextTree());
 
                 }
                 stream_nodeValue.reset();
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:265:37: ( dataType )?
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:44: ( dataType )?
                 if ( stream_dataType.hasNext() ) {
                     adaptor.addChild(root_0, stream_dataType.nextTree());
 
                 }
                 stream_dataType.reset();
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:265:47: ( plural )?
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:54: ( plural )?
                 if ( stream_plural.hasNext() ) {
                     adaptor.addChild(root_0, stream_plural.nextTree());
 
                 }
                 stream_plural.reset();
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:265:55: ( attributeList )?
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:264:62: ( attributeList )?
                 if ( stream_attributeList.hasNext() ) {
                     adaptor.addChild(root_0, stream_attributeList.nextTree());
 
@@ -904,7 +888,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "dataType"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:269:1: dataType : LBracket dataTypeName RBracket ;
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:268:1: dataType : LBracket dataTypeName RBracket ;
     public final SilkParser.dataType_return dataType() throws RecognitionException {
         SilkParser.dataType_return retval = new SilkParser.dataType_return();
         retval.start = input.LT(1);
@@ -920,19 +904,19 @@ public class SilkParser extends Parser {
         Object RBracket24_tree=null;
 
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:269:9: ( LBracket dataTypeName RBracket )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:269:11: LBracket dataTypeName RBracket
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:268:9: ( LBracket dataTypeName RBracket )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:268:11: LBracket dataTypeName RBracket
             {
             root_0 = (Object)adaptor.nil();
 
-            LBracket22=(Token)match(input,LBracket,FOLLOW_LBracket_in_dataType1123); 
-            pushFollow(FOLLOW_dataTypeName_in_dataType1126);
+            LBracket22=(Token)match(input,LBracket,FOLLOW_LBracket_in_dataType1133); 
+            pushFollow(FOLLOW_dataTypeName_in_dataType1136);
             dataTypeName23=dataTypeName();
 
             state._fsp--;
 
             adaptor.addChild(root_0, dataTypeName23.getTree());
-            RBracket24=(Token)match(input,RBracket,FOLLOW_RBracket_in_dataType1128); 
+            RBracket24=(Token)match(input,RBracket,FOLLOW_RBracket_in_dataType1138); 
 
             }
 
@@ -960,7 +944,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "dataTypeName"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:272:1: dataTypeName : PlainOneLine -> DataType[$dataTypeName.text] ;
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:271:1: dataTypeName : PlainOneLine -> DataType[$dataTypeName.text] ;
     public final SilkParser.dataTypeName_return dataTypeName() throws RecognitionException {
         SilkParser.dataTypeName_return retval = new SilkParser.dataTypeName_return();
         retval.start = input.LT(1);
@@ -973,10 +957,10 @@ public class SilkParser extends Parser {
         RewriteRuleTokenStream stream_PlainOneLine=new RewriteRuleTokenStream(adaptor,"token PlainOneLine");
 
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:272:13: ( PlainOneLine -> DataType[$dataTypeName.text] )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:272:15: PlainOneLine
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:271:13: ( PlainOneLine -> DataType[$dataTypeName.text] )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:271:15: PlainOneLine
             {
-            PlainOneLine25=(Token)match(input,PlainOneLine,FOLLOW_PlainOneLine_in_dataTypeName1139);  
+            PlainOneLine25=(Token)match(input,PlainOneLine,FOLLOW_PlainOneLine_in_dataTypeName1149);  
             stream_PlainOneLine.add(PlainOneLine25);
 
 
@@ -991,7 +975,7 @@ public class SilkParser extends Parser {
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
             root_0 = (Object)adaptor.nil();
-            // 273:2: -> DataType[$dataTypeName.text]
+            // 272:2: -> DataType[$dataTypeName.text]
             {
                 adaptor.addChild(root_0, (Object)adaptor.create(DataType, input.toString(retval.start,input.LT(-1))));
 
@@ -1024,7 +1008,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "attributeList"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:276:1: attributeList : attributeItem ( Comma attributeItem )* ;
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:275:1: attributeList : attributeItem ( Comma attributeItem )* ;
     public final SilkParser.attributeList_return attributeList() throws RecognitionException {
         SilkParser.attributeList_return retval = new SilkParser.attributeList_return();
         retval.start = input.LT(1);
@@ -1040,18 +1024,18 @@ public class SilkParser extends Parser {
         Object Comma27_tree=null;
 
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:276:14: ( attributeItem ( Comma attributeItem )* )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:276:16: attributeItem ( Comma attributeItem )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:275:14: ( attributeItem ( Comma attributeItem )* )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:275:16: attributeItem ( Comma attributeItem )*
             {
             root_0 = (Object)adaptor.nil();
 
-            pushFollow(FOLLOW_attributeItem_in_attributeList1157);
+            pushFollow(FOLLOW_attributeItem_in_attributeList1167);
             attributeItem26=attributeItem();
 
             state._fsp--;
 
             adaptor.addChild(root_0, attributeItem26.getTree());
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:276:30: ( Comma attributeItem )*
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:275:30: ( Comma attributeItem )*
             loop9:
             do {
                 int alt9=2;
@@ -1064,10 +1048,10 @@ public class SilkParser extends Parser {
 
                 switch (alt9) {
             	case 1 :
-            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:276:31: Comma attributeItem
+            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:275:31: Comma attributeItem
             	    {
-            	    Comma27=(Token)match(input,Comma,FOLLOW_Comma_in_attributeList1160); 
-            	    pushFollow(FOLLOW_attributeItem_in_attributeList1163);
+            	    Comma27=(Token)match(input,Comma,FOLLOW_Comma_in_attributeList1170); 
+            	    pushFollow(FOLLOW_attributeItem_in_attributeList1173);
             	    attributeItem28=attributeItem();
 
             	    state._fsp--;
@@ -1109,7 +1093,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "attributeItem"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:277:1: attributeItem : nodeItem -> ^( SilkNode nodeItem ) ;
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:276:1: attributeItem : nodeItem -> ^( SilkNode nodeItem ) ;
     public final SilkParser.attributeItem_return attributeItem() throws RecognitionException {
         SilkParser.attributeItem_return retval = new SilkParser.attributeItem_return();
         retval.start = input.LT(1);
@@ -1121,10 +1105,10 @@ public class SilkParser extends Parser {
 
         RewriteRuleSubtreeStream stream_nodeItem=new RewriteRuleSubtreeStream(adaptor,"rule nodeItem");
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:277:14: ( nodeItem -> ^( SilkNode nodeItem ) )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:277:16: nodeItem
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:276:14: ( nodeItem -> ^( SilkNode nodeItem ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:276:16: nodeItem
             {
-            pushFollow(FOLLOW_nodeItem_in_attributeItem1173);
+            pushFollow(FOLLOW_nodeItem_in_attributeItem1183);
             nodeItem29=nodeItem();
 
             state._fsp--;
@@ -1142,9 +1126,9 @@ public class SilkParser extends Parser {
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
             root_0 = (Object)adaptor.nil();
-            // 277:25: -> ^( SilkNode nodeItem )
+            // 276:25: -> ^( SilkNode nodeItem )
             {
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:277:28: ^( SilkNode nodeItem )
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:276:28: ^( SilkNode nodeItem )
                 {
                 Object root_1 = (Object)adaptor.nil();
                 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(SilkNode, "SilkNode"), root_1);
@@ -1183,7 +1167,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "plural"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:280:1: plural : ( Star -> Occurrence[\"ZERO_OR_MORE\"] | Plus -> Occurrence[\"ONE_OR_MORE\"] | Question -> Occurrence[\"ZERO_OR_ONE\"] | Seq -> Occurrence[\"SEQUENCE\"] | TabSeq -> Occurrence[\"TABBED_SEQUENCE\"] );
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:279:1: plural : ( Star -> Occurrence[\"ZERO_OR_MORE\"] | Plus -> Occurrence[\"ONE_OR_MORE\"] | Question -> Occurrence[\"ZERO_OR_ONE\"] | Seq -> Occurrence[\"SEQUENCE\"] | TabSeq -> Occurrence[\"TABBED_SEQUENCE\"] );
     public final SilkParser.plural_return plural() throws RecognitionException {
         SilkParser.plural_return retval = new SilkParser.plural_return();
         retval.start = input.LT(1);
@@ -1208,7 +1192,7 @@ public class SilkParser extends Parser {
         RewriteRuleTokenStream stream_Seq=new RewriteRuleTokenStream(adaptor,"token Seq");
 
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:281:2: ( Star -> Occurrence[\"ZERO_OR_MORE\"] | Plus -> Occurrence[\"ONE_OR_MORE\"] | Question -> Occurrence[\"ZERO_OR_ONE\"] | Seq -> Occurrence[\"SEQUENCE\"] | TabSeq -> Occurrence[\"TABBED_SEQUENCE\"] )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:280:2: ( Star -> Occurrence[\"ZERO_OR_MORE\"] | Plus -> Occurrence[\"ONE_OR_MORE\"] | Question -> Occurrence[\"ZERO_OR_ONE\"] | Seq -> Occurrence[\"SEQUENCE\"] | TabSeq -> Occurrence[\"TABBED_SEQUENCE\"] )
             int alt10=5;
             switch ( input.LA(1) ) {
             case Star:
@@ -1245,9 +1229,9 @@ public class SilkParser extends Parser {
 
             switch (alt10) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:281:4: Star
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:280:4: Star
                     {
-                    Star30=(Token)match(input,Star,FOLLOW_Star_in_plural1191);  
+                    Star30=(Token)match(input,Star,FOLLOW_Star_in_plural1201);  
                     stream_Star.add(Star30);
 
 
@@ -1262,7 +1246,7 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 281:9: -> Occurrence[\"ZERO_OR_MORE\"]
+                    // 280:9: -> Occurrence[\"ZERO_OR_MORE\"]
                     {
                         adaptor.addChild(root_0, (Object)adaptor.create(Occurrence, "ZERO_OR_MORE"));
 
@@ -1272,9 +1256,9 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:282:4: Plus
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:281:4: Plus
                     {
-                    Plus31=(Token)match(input,Plus,FOLLOW_Plus_in_plural1201);  
+                    Plus31=(Token)match(input,Plus,FOLLOW_Plus_in_plural1211);  
                     stream_Plus.add(Plus31);
 
 
@@ -1289,7 +1273,7 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 282:9: -> Occurrence[\"ONE_OR_MORE\"]
+                    // 281:9: -> Occurrence[\"ONE_OR_MORE\"]
                     {
                         adaptor.addChild(root_0, (Object)adaptor.create(Occurrence, "ONE_OR_MORE"));
 
@@ -1299,9 +1283,9 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 3 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:283:4: Question
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:282:4: Question
                     {
-                    Question32=(Token)match(input,Question,FOLLOW_Question_in_plural1211);  
+                    Question32=(Token)match(input,Question,FOLLOW_Question_in_plural1221);  
                     stream_Question.add(Question32);
 
 
@@ -1316,7 +1300,7 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 283:13: -> Occurrence[\"ZERO_OR_ONE\"]
+                    // 282:13: -> Occurrence[\"ZERO_OR_ONE\"]
                     {
                         adaptor.addChild(root_0, (Object)adaptor.create(Occurrence, "ZERO_OR_ONE"));
 
@@ -1326,9 +1310,9 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 4 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:284:4: Seq
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:283:4: Seq
                     {
-                    Seq33=(Token)match(input,Seq,FOLLOW_Seq_in_plural1221);  
+                    Seq33=(Token)match(input,Seq,FOLLOW_Seq_in_plural1231);  
                     stream_Seq.add(Seq33);
 
 
@@ -1343,7 +1327,7 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 284:8: -> Occurrence[\"SEQUENCE\"]
+                    // 283:8: -> Occurrence[\"SEQUENCE\"]
                     {
                         adaptor.addChild(root_0, (Object)adaptor.create(Occurrence, "SEQUENCE"));
 
@@ -1353,9 +1337,9 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 5 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:285:4: TabSeq
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:284:4: TabSeq
                     {
-                    TabSeq34=(Token)match(input,TabSeq,FOLLOW_TabSeq_in_plural1231);  
+                    TabSeq34=(Token)match(input,TabSeq,FOLLOW_TabSeq_in_plural1241);  
                     stream_TabSeq.add(TabSeq34);
 
 
@@ -1370,7 +1354,7 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 285:11: -> Occurrence[\"TABBED_SEQUENCE\"]
+                    // 284:11: -> Occurrence[\"TABBED_SEQUENCE\"]
                     {
                         adaptor.addChild(root_0, (Object)adaptor.create(Occurrence, "TABBED_SEQUENCE"));
 
@@ -1405,7 +1389,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "function"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:288:1: function : ( NodeIndent function_i -> ^( Function NodeIndent function_i ) | FunctionIndent PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen -> ^( Function NodeIndent[$FunctionIndent.text] Name[$PlainOneLine.text] ( functionArg )* ) );
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:287:1: function : ( NodeIndent function_i -> ^( Function NodeIndent function_i ) | FunctionIndent PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen -> ^( Function NodeIndent[$FunctionIndent.text] Name[$PlainOneLine.text.trim()] ( functionArg )* ) );
     public final SilkParser.function_return function() throws RecognitionException {
         SilkParser.function_return retval = new SilkParser.function_return();
         retval.start = input.LT(1);
@@ -1440,7 +1424,7 @@ public class SilkParser extends Parser {
         RewriteRuleSubtreeStream stream_function_i=new RewriteRuleSubtreeStream(adaptor,"rule function_i");
         RewriteRuleSubtreeStream stream_functionArg=new RewriteRuleSubtreeStream(adaptor,"rule functionArg");
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:289:2: ( NodeIndent function_i -> ^( Function NodeIndent function_i ) | FunctionIndent PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen -> ^( Function NodeIndent[$FunctionIndent.text] Name[$PlainOneLine.text] ( functionArg )* ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:288:2: ( NodeIndent function_i -> ^( Function NodeIndent function_i ) | FunctionIndent PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen -> ^( Function NodeIndent[$FunctionIndent.text] Name[$PlainOneLine.text.trim()] ( functionArg )* ) )
             int alt13=2;
             int LA13_0 = input.LA(1);
 
@@ -1458,12 +1442,12 @@ public class SilkParser extends Parser {
             }
             switch (alt13) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:289:4: NodeIndent function_i
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:288:4: NodeIndent function_i
                     {
-                    NodeIndent35=(Token)match(input,NodeIndent,FOLLOW_NodeIndent_in_function1247);  
+                    NodeIndent35=(Token)match(input,NodeIndent,FOLLOW_NodeIndent_in_function1257);  
                     stream_NodeIndent.add(NodeIndent35);
 
-                    pushFollow(FOLLOW_function_i_in_function1249);
+                    pushFollow(FOLLOW_function_i_in_function1259);
                     function_i36=function_i();
 
                     state._fsp--;
@@ -1472,7 +1456,7 @@ public class SilkParser extends Parser {
 
 
                     // AST REWRITE
-                    // elements: function_i, NodeIndent
+                    // elements: NodeIndent, function_i
                     // token labels: 
                     // rule labels: retval
                     // token list labels: 
@@ -1481,9 +1465,9 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 290:2: -> ^( Function NodeIndent function_i )
+                    // 289:2: -> ^( Function NodeIndent function_i )
                     {
-                        // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:290:5: ^( Function NodeIndent function_i )
+                        // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:289:5: ^( Function NodeIndent function_i )
                         {
                         Object root_1 = (Object)adaptor.nil();
                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(Function, "Function"), root_1);
@@ -1500,18 +1484,18 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:291:4: FunctionIndent PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:290:4: FunctionIndent PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen
                     {
-                    FunctionIndent37=(Token)match(input,FunctionIndent,FOLLOW_FunctionIndent_in_function1265);  
+                    FunctionIndent37=(Token)match(input,FunctionIndent,FOLLOW_FunctionIndent_in_function1275);  
                     stream_FunctionIndent.add(FunctionIndent37);
 
-                    PlainOneLine38=(Token)match(input,PlainOneLine,FOLLOW_PlainOneLine_in_function1267);  
+                    PlainOneLine38=(Token)match(input,PlainOneLine,FOLLOW_PlainOneLine_in_function1277);  
                     stream_PlainOneLine.add(PlainOneLine38);
 
-                    LParen39=(Token)match(input,LParen,FOLLOW_LParen_in_function1269);  
+                    LParen39=(Token)match(input,LParen,FOLLOW_LParen_in_function1279);  
                     stream_LParen.add(LParen39);
 
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:291:39: ( functionArg ( Comma functionArg )* )?
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:290:39: ( functionArg ( Comma functionArg )* )?
                     int alt12=2;
                     int LA12_0 = input.LA(1);
 
@@ -1520,15 +1504,15 @@ public class SilkParser extends Parser {
                     }
                     switch (alt12) {
                         case 1 :
-                            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:291:40: functionArg ( Comma functionArg )*
+                            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:290:40: functionArg ( Comma functionArg )*
                             {
-                            pushFollow(FOLLOW_functionArg_in_function1272);
+                            pushFollow(FOLLOW_functionArg_in_function1282);
                             functionArg40=functionArg();
 
                             state._fsp--;
 
                             stream_functionArg.add(functionArg40.getTree());
-                            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:291:52: ( Comma functionArg )*
+                            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:290:52: ( Comma functionArg )*
                             loop11:
                             do {
                                 int alt11=2;
@@ -1541,12 +1525,12 @@ public class SilkParser extends Parser {
 
                                 switch (alt11) {
                             	case 1 :
-                            	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:291:53: Comma functionArg
+                            	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:290:53: Comma functionArg
                             	    {
-                            	    Comma41=(Token)match(input,Comma,FOLLOW_Comma_in_function1275);  
+                            	    Comma41=(Token)match(input,Comma,FOLLOW_Comma_in_function1285);  
                             	    stream_Comma.add(Comma41);
 
-                            	    pushFollow(FOLLOW_functionArg_in_function1277);
+                            	    pushFollow(FOLLOW_functionArg_in_function1287);
                             	    functionArg42=functionArg();
 
                             	    state._fsp--;
@@ -1567,7 +1551,7 @@ public class SilkParser extends Parser {
 
                     }
 
-                    RParen43=(Token)match(input,RParen,FOLLOW_RParen_in_function1283);  
+                    RParen43=(Token)match(input,RParen,FOLLOW_RParen_in_function1293);  
                     stream_RParen.add(RParen43);
 
 
@@ -1582,16 +1566,16 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 292:2: -> ^( Function NodeIndent[$FunctionIndent.text] Name[$PlainOneLine.text] ( functionArg )* )
+                    // 291:2: -> ^( Function NodeIndent[$FunctionIndent.text] Name[$PlainOneLine.text.trim()] ( functionArg )* )
                     {
-                        // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:292:5: ^( Function NodeIndent[$FunctionIndent.text] Name[$PlainOneLine.text] ( functionArg )* )
+                        // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:291:5: ^( Function NodeIndent[$FunctionIndent.text] Name[$PlainOneLine.text.trim()] ( functionArg )* )
                         {
                         Object root_1 = (Object)adaptor.nil();
                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(Function, "Function"), root_1);
 
                         adaptor.addChild(root_1, (Object)adaptor.create(NodeIndent, (FunctionIndent37!=null?FunctionIndent37.getText():null)));
-                        adaptor.addChild(root_1, (Object)adaptor.create(Name, (PlainOneLine38!=null?PlainOneLine38.getText():null)));
-                        // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:292:74: ( functionArg )*
+                        adaptor.addChild(root_1, (Object)adaptor.create(Name, (PlainOneLine38!=null?PlainOneLine38.getText():null).trim()));
+                        // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:291:81: ( functionArg )*
                         while ( stream_functionArg.hasNext() ) {
                             adaptor.addChild(root_1, stream_functionArg.nextTree());
 
@@ -1632,7 +1616,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "function_i"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:296:1: function_i : At PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen -> Name[$PlainOneLine.text] ( functionArg )* ;
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:295:1: function_i : At PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen -> Name[$PlainOneLine.text] ( functionArg )* ;
     public final SilkParser.function_i_return function_i() throws RecognitionException {
         SilkParser.function_i_return retval = new SilkParser.function_i_return();
         retval.start = input.LT(1);
@@ -1661,19 +1645,19 @@ public class SilkParser extends Parser {
         RewriteRuleTokenStream stream_LParen=new RewriteRuleTokenStream(adaptor,"token LParen");
         RewriteRuleSubtreeStream stream_functionArg=new RewriteRuleSubtreeStream(adaptor,"rule functionArg");
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:296:11: ( At PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen -> Name[$PlainOneLine.text] ( functionArg )* )
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:296:13: At PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:295:11: ( At PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen -> Name[$PlainOneLine.text] ( functionArg )* )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:295:13: At PlainOneLine LParen ( functionArg ( Comma functionArg )* )? RParen
             {
-            At44=(Token)match(input,At,FOLLOW_At_in_function_i1309);  
+            At44=(Token)match(input,At,FOLLOW_At_in_function_i1319);  
             stream_At.add(At44);
 
-            PlainOneLine45=(Token)match(input,PlainOneLine,FOLLOW_PlainOneLine_in_function_i1311);  
+            PlainOneLine45=(Token)match(input,PlainOneLine,FOLLOW_PlainOneLine_in_function_i1321);  
             stream_PlainOneLine.add(PlainOneLine45);
 
-            LParen46=(Token)match(input,LParen,FOLLOW_LParen_in_function_i1313);  
+            LParen46=(Token)match(input,LParen,FOLLOW_LParen_in_function_i1323);  
             stream_LParen.add(LParen46);
 
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:296:36: ( functionArg ( Comma functionArg )* )?
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:295:36: ( functionArg ( Comma functionArg )* )?
             int alt15=2;
             int LA15_0 = input.LA(1);
 
@@ -1682,15 +1666,15 @@ public class SilkParser extends Parser {
             }
             switch (alt15) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:296:37: functionArg ( Comma functionArg )*
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:295:37: functionArg ( Comma functionArg )*
                     {
-                    pushFollow(FOLLOW_functionArg_in_function_i1316);
+                    pushFollow(FOLLOW_functionArg_in_function_i1326);
                     functionArg47=functionArg();
 
                     state._fsp--;
 
                     stream_functionArg.add(functionArg47.getTree());
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:296:49: ( Comma functionArg )*
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:295:49: ( Comma functionArg )*
                     loop14:
                     do {
                         int alt14=2;
@@ -1703,12 +1687,12 @@ public class SilkParser extends Parser {
 
                         switch (alt14) {
                     	case 1 :
-                    	    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:296:50: Comma functionArg
+                    	    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:295:50: Comma functionArg
                     	    {
-                    	    Comma48=(Token)match(input,Comma,FOLLOW_Comma_in_function_i1319);  
+                    	    Comma48=(Token)match(input,Comma,FOLLOW_Comma_in_function_i1329);  
                     	    stream_Comma.add(Comma48);
 
-                    	    pushFollow(FOLLOW_functionArg_in_function_i1321);
+                    	    pushFollow(FOLLOW_functionArg_in_function_i1331);
                     	    functionArg49=functionArg();
 
                     	    state._fsp--;
@@ -1729,7 +1713,7 @@ public class SilkParser extends Parser {
 
             }
 
-            RParen50=(Token)match(input,RParen,FOLLOW_RParen_in_function_i1327);  
+            RParen50=(Token)match(input,RParen,FOLLOW_RParen_in_function_i1337);  
             stream_RParen.add(RParen50);
 
 
@@ -1744,10 +1728,10 @@ public class SilkParser extends Parser {
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
             root_0 = (Object)adaptor.nil();
-            // 297:2: -> Name[$PlainOneLine.text] ( functionArg )*
+            // 296:2: -> Name[$PlainOneLine.text] ( functionArg )*
             {
                 adaptor.addChild(root_0, (Object)adaptor.create(Name, (PlainOneLine45!=null?PlainOneLine45.getText():null)));
-                // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:297:30: ( functionArg )*
+                // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:296:30: ( functionArg )*
                 while ( stream_functionArg.hasNext() ) {
                     adaptor.addChild(root_0, stream_functionArg.nextTree());
 
@@ -1783,7 +1767,7 @@ public class SilkParser extends Parser {
     };
 
     // $ANTLR start "functionArg"
-    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:301:1: functionArg : ( nodeValue -> Argument[$functionArg.text] | nodeName Colon nodeValue -> ^( KeyValuePair Name[$nodeName.text] nodeValue ) );
+    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:300:1: functionArg : ( nodeValue -> Argument[$functionArg.text] | nodeName Colon nodeValue -> ^( KeyValuePair Name[$nodeName.text.trim()] nodeValue ) );
     public final SilkParser.functionArg_return functionArg() throws RecognitionException {
         SilkParser.functionArg_return retval = new SilkParser.functionArg_return();
         retval.start = input.LT(1);
@@ -1803,63 +1787,14 @@ public class SilkParser extends Parser {
         RewriteRuleSubtreeStream stream_nodeName=new RewriteRuleSubtreeStream(adaptor,"rule nodeName");
         RewriteRuleSubtreeStream stream_nodeValue=new RewriteRuleSubtreeStream(adaptor,"rule nodeValue");
         try {
-            // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:302:2: ( nodeValue -> Argument[$functionArg.text] | nodeName Colon nodeValue -> ^( KeyValuePair Name[$nodeName.text] nodeValue ) )
+            // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:301:2: ( nodeValue -> Argument[$functionArg.text] | nodeName Colon nodeValue -> ^( KeyValuePair Name[$nodeName.text.trim()] nodeValue ) )
             int alt16=2;
-            switch ( input.LA(1) ) {
-            case At:
-            case JSON:
-                {
-                alt16=1;
-                }
-                break;
-            case PlainOneLine:
-                {
-                int LA16_2 = input.LA(2);
-
-                if ( ((LA16_2>=RParen && LA16_2<=Comma)) ) {
-                    alt16=1;
-                }
-                else if ( (LA16_2==Colon) ) {
-                    alt16=2;
-                }
-                else {
-                    NoViableAltException nvae =
-                        new NoViableAltException("", 16, 2, input);
-
-                    throw nvae;
-                }
-                }
-                break;
-            case String:
-                {
-                int LA16_3 = input.LA(2);
-
-                if ( ((LA16_3>=RParen && LA16_3<=Comma)) ) {
-                    alt16=1;
-                }
-                else if ( (LA16_3==Colon) ) {
-                    alt16=2;
-                }
-                else {
-                    NoViableAltException nvae =
-                        new NoViableAltException("", 16, 3, input);
-
-                    throw nvae;
-                }
-                }
-                break;
-            default:
-                NoViableAltException nvae =
-                    new NoViableAltException("", 16, 0, input);
-
-                throw nvae;
-            }
-
+            alt16 = dfa16.predict(input);
             switch (alt16) {
                 case 1 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:302:4: nodeValue
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:301:4: nodeValue
                     {
-                    pushFollow(FOLLOW_nodeValue_in_functionArg1348);
+                    pushFollow(FOLLOW_nodeValue_in_functionArg1358);
                     nodeValue51=nodeValue();
 
                     state._fsp--;
@@ -1877,7 +1812,7 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 302:14: -> Argument[$functionArg.text]
+                    // 301:14: -> Argument[$functionArg.text]
                     {
                         adaptor.addChild(root_0, (Object)adaptor.create(Argument, input.toString(retval.start,input.LT(-1))));
 
@@ -1887,18 +1822,18 @@ public class SilkParser extends Parser {
                     }
                     break;
                 case 2 :
-                    // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:303:4: nodeName Colon nodeValue
+                    // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:302:4: nodeName Colon nodeValue
                     {
-                    pushFollow(FOLLOW_nodeName_in_functionArg1358);
+                    pushFollow(FOLLOW_nodeName_in_functionArg1368);
                     nodeName52=nodeName();
 
                     state._fsp--;
 
                     stream_nodeName.add(nodeName52.getTree());
-                    Colon53=(Token)match(input,Colon,FOLLOW_Colon_in_functionArg1360);  
+                    Colon53=(Token)match(input,Colon,FOLLOW_Colon_in_functionArg1370);  
                     stream_Colon.add(Colon53);
 
-                    pushFollow(FOLLOW_nodeValue_in_functionArg1362);
+                    pushFollow(FOLLOW_nodeValue_in_functionArg1372);
                     nodeValue54=nodeValue();
 
                     state._fsp--;
@@ -1916,14 +1851,14 @@ public class SilkParser extends Parser {
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 
                     root_0 = (Object)adaptor.nil();
-                    // 303:29: -> ^( KeyValuePair Name[$nodeName.text] nodeValue )
+                    // 302:29: -> ^( KeyValuePair Name[$nodeName.text.trim()] nodeValue )
                     {
-                        // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:303:32: ^( KeyValuePair Name[$nodeName.text] nodeValue )
+                        // c:\\Users\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:302:32: ^( KeyValuePair Name[$nodeName.text.trim()] nodeValue )
                         {
                         Object root_1 = (Object)adaptor.nil();
                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(KeyValuePair, "KeyValuePair"), root_1);
 
-                        adaptor.addChild(root_1, (Object)adaptor.create(Name, (nodeName52!=null?input.toString(nodeName52.start,nodeName52.stop):null)));
+                        adaptor.addChild(root_1, (Object)adaptor.create(Name, (nodeName52!=null?input.toString(nodeName52.start,nodeName52.stop):null).trim()));
                         adaptor.addChild(root_1, stream_nodeValue.nextTree());
 
                         adaptor.addChild(root_0, root_1);
@@ -1957,61 +1892,381 @@ public class SilkParser extends Parser {
     // Delegated rules
 
 
+    protected DFA5 dfa5 = new DFA5(this);
+    protected DFA6 dfa6 = new DFA6(this);
+    protected DFA7 dfa7 = new DFA7(this);
+    protected DFA8 dfa8 = new DFA8(this);
+    protected DFA16 dfa16 = new DFA16(this);
+    static final String DFA5_eotS =
+        "\22\uffff";
+    static final String DFA5_eofS =
+        "\1\2\21\uffff";
+    static final String DFA5_minS =
+        "\1\20\21\uffff";
+    static final String DFA5_maxS =
+        "\1\44\21\uffff";
+    static final String DFA5_acceptS =
+        "\1\uffff\1\1\1\2\17\uffff";
+    static final String DFA5_specialS =
+        "\22\uffff}>";
+    static final String[] DFA5_transitionS = {
+            "\1\2\2\uffff\4\2\1\uffff\10\2\1\uffff\1\2\1\1\1\uffff\1\2",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] DFA5_eot = DFA.unpackEncodedString(DFA5_eotS);
+    static final short[] DFA5_eof = DFA.unpackEncodedString(DFA5_eofS);
+    static final char[] DFA5_min = DFA.unpackEncodedStringToUnsignedChars(DFA5_minS);
+    static final char[] DFA5_max = DFA.unpackEncodedStringToUnsignedChars(DFA5_maxS);
+    static final short[] DFA5_accept = DFA.unpackEncodedString(DFA5_acceptS);
+    static final short[] DFA5_special = DFA.unpackEncodedString(DFA5_specialS);
+    static final short[][] DFA5_transition;
+
+    static {
+        int numStates = DFA5_transitionS.length;
+        DFA5_transition = new short[numStates][];
+        for (int i=0; i<numStates; i++) {
+            DFA5_transition[i] = DFA.unpackEncodedString(DFA5_transitionS[i]);
+        }
+    }
+
+    class DFA5 extends DFA {
+
+        public DFA5(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 5;
+            this.eot = DFA5_eot;
+            this.eof = DFA5_eof;
+            this.min = DFA5_min;
+            this.max = DFA5_max;
+            this.accept = DFA5_accept;
+            this.special = DFA5_special;
+            this.transition = DFA5_transition;
+        }
+        public String getDescription() {
+            return "263:20: ( dataType )?";
+        }
+    }
+    static final String DFA6_eotS =
+        "\21\uffff";
+    static final String DFA6_eofS =
+        "\1\2\20\uffff";
+    static final String DFA6_minS =
+        "\1\20\20\uffff";
+    static final String DFA6_maxS =
+        "\1\44\20\uffff";
+    static final String DFA6_acceptS =
+        "\1\uffff\1\1\1\2\16\uffff";
+    static final String DFA6_specialS =
+        "\21\uffff}>";
+    static final String[] DFA6_transitionS = {
+            "\1\2\2\uffff\4\2\1\uffff\1\2\1\1\6\2\1\uffff\1\2\2\uffff\1"+
+            "\2",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] DFA6_eot = DFA.unpackEncodedString(DFA6_eotS);
+    static final short[] DFA6_eof = DFA.unpackEncodedString(DFA6_eofS);
+    static final char[] DFA6_min = DFA.unpackEncodedStringToUnsignedChars(DFA6_minS);
+    static final char[] DFA6_max = DFA.unpackEncodedStringToUnsignedChars(DFA6_maxS);
+    static final short[] DFA6_accept = DFA.unpackEncodedString(DFA6_acceptS);
+    static final short[] DFA6_special = DFA.unpackEncodedString(DFA6_specialS);
+    static final short[][] DFA6_transition;
+
+    static {
+        int numStates = DFA6_transitionS.length;
+        DFA6_transition = new short[numStates][];
+        for (int i=0; i<numStates; i++) {
+            DFA6_transition[i] = DFA.unpackEncodedString(DFA6_transitionS[i]);
+        }
+    }
+
+    class DFA6 extends DFA {
+
+        public DFA6(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 6;
+            this.eot = DFA6_eot;
+            this.eof = DFA6_eof;
+            this.min = DFA6_min;
+            this.max = DFA6_max;
+            this.accept = DFA6_accept;
+            this.special = DFA6_special;
+            this.transition = DFA6_transition;
+        }
+        public String getDescription() {
+            return "263:30: ( LParen attributeList RParen )?";
+        }
+    }
+    static final String DFA7_eotS =
+        "\20\uffff";
+    static final String DFA7_eofS =
+        "\1\6\17\uffff";
+    static final String DFA7_minS =
+        "\1\20\17\uffff";
+    static final String DFA7_maxS =
+        "\1\44\17\uffff";
+    static final String DFA7_acceptS =
+        "\1\uffff\1\1\4\uffff\1\2\11\uffff";
+    static final String DFA7_specialS =
+        "\20\uffff}>";
+    static final String[] DFA7_transitionS = {
+            "\1\6\2\uffff\4\6\1\uffff\1\6\1\uffff\3\6\3\1\1\uffff\1\1\2"+
+            "\uffff\1\1",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] DFA7_eot = DFA.unpackEncodedString(DFA7_eotS);
+    static final short[] DFA7_eof = DFA.unpackEncodedString(DFA7_eofS);
+    static final char[] DFA7_min = DFA.unpackEncodedStringToUnsignedChars(DFA7_minS);
+    static final char[] DFA7_max = DFA.unpackEncodedStringToUnsignedChars(DFA7_maxS);
+    static final short[] DFA7_accept = DFA.unpackEncodedString(DFA7_acceptS);
+    static final short[] DFA7_special = DFA.unpackEncodedString(DFA7_specialS);
+    static final short[][] DFA7_transition;
+
+    static {
+        int numStates = DFA7_transitionS.length;
+        DFA7_transition = new short[numStates][];
+        for (int i=0; i<numStates; i++) {
+            DFA7_transition[i] = DFA.unpackEncodedString(DFA7_transitionS[i]);
+        }
+    }
+
+    class DFA7 extends DFA {
+
+        public DFA7(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 7;
+            this.eot = DFA7_eot;
+            this.eof = DFA7_eof;
+            this.min = DFA7_min;
+            this.max = DFA7_max;
+            this.accept = DFA7_accept;
+            this.special = DFA7_special;
+            this.transition = DFA7_transition;
+        }
+        public String getDescription() {
+            return "263:61: ( plural )?";
+        }
+    }
+    static final String DFA8_eotS =
+        "\13\uffff";
+    static final String DFA8_eofS =
+        "\1\2\12\uffff";
+    static final String DFA8_minS =
+        "\1\20\12\uffff";
+    static final String DFA8_maxS =
+        "\1\34\12\uffff";
+    static final String DFA8_acceptS =
+        "\1\uffff\1\1\1\2\10\uffff";
+    static final String DFA8_specialS =
+        "\13\uffff}>";
+    static final String[] DFA8_transitionS = {
+            "\1\2\2\uffff\4\2\1\uffff\1\2\1\uffff\2\2\1\1",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
+    static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS);
+    static final char[] DFA8_min = DFA.unpackEncodedStringToUnsignedChars(DFA8_minS);
+    static final char[] DFA8_max = DFA.unpackEncodedStringToUnsignedChars(DFA8_maxS);
+    static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS);
+    static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS);
+    static final short[][] DFA8_transition;
+
+    static {
+        int numStates = DFA8_transitionS.length;
+        DFA8_transition = new short[numStates][];
+        for (int i=0; i<numStates; i++) {
+            DFA8_transition[i] = DFA.unpackEncodedString(DFA8_transitionS[i]);
+        }
+    }
+
+    class DFA8 extends DFA {
+
+        public DFA8(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 8;
+            this.eot = DFA8_eot;
+            this.eof = DFA8_eof;
+            this.min = DFA8_min;
+            this.max = DFA8_max;
+            this.accept = DFA8_accept;
+            this.special = DFA8_special;
+            this.transition = DFA8_transition;
+        }
+        public String getDescription() {
+            return "263:69: ( Colon nodeValue )?";
+        }
+    }
+    static final String DFA16_eotS =
+        "\13\uffff";
+    static final String DFA16_eofS =
+        "\13\uffff";
+    static final String DFA16_minS =
+        "\1\40\1\uffff\2\32\7\uffff";
+    static final String DFA16_maxS =
+        "\1\70\1\uffff\2\34\7\uffff";
+    static final String DFA16_acceptS =
+        "\1\uffff\1\1\5\uffff\1\2\3\uffff";
+    static final String DFA16_specialS =
+        "\13\uffff}>";
+    static final String[] DFA16_transitionS = {
+            "\1\1\14\uffff\1\3\11\uffff\1\2\1\1",
+            "",
+            "\2\1\1\7",
+            "\2\1\1\7",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] DFA16_eot = DFA.unpackEncodedString(DFA16_eotS);
+    static final short[] DFA16_eof = DFA.unpackEncodedString(DFA16_eofS);
+    static final char[] DFA16_min = DFA.unpackEncodedStringToUnsignedChars(DFA16_minS);
+    static final char[] DFA16_max = DFA.unpackEncodedStringToUnsignedChars(DFA16_maxS);
+    static final short[] DFA16_accept = DFA.unpackEncodedString(DFA16_acceptS);
+    static final short[] DFA16_special = DFA.unpackEncodedString(DFA16_specialS);
+    static final short[][] DFA16_transition;
+
+    static {
+        int numStates = DFA16_transitionS.length;
+        DFA16_transition = new short[numStates][];
+        for (int i=0; i<numStates; i++) {
+            DFA16_transition[i] = DFA.unpackEncodedString(DFA16_transitionS[i]);
+        }
+    }
+
+    class DFA16 extends DFA {
+
+        public DFA16(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 16;
+            this.eot = DFA16_eot;
+            this.eof = DFA16_eof;
+            this.min = DFA16_min;
+            this.max = DFA16_max;
+            this.accept = DFA16_accept;
+            this.special = DFA16_special;
+            this.transition = DFA16_transition;
+        }
+        public String getDescription() {
+            return "300:1: functionArg : ( nodeValue -> Argument[$functionArg.text] | nodeName Colon nodeValue -> ^( KeyValuePair Name[$nodeName.text.trim()] nodeValue ) );";
+        }
+    }
  
 
-    public static final BitSet FOLLOW_silkLine_in_silkFile946 = new BitSet(new long[]{0x0000000001790002L});
-    public static final BitSet FOLLOW_NodeIndent_in_silkLine967 = new BitSet(new long[]{0x0080200000000000L});
-    public static final BitSet FOLLOW_nodeItem_in_silkLine969 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_function_in_silkLine985 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_Preamble_in_silkLine990 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_DataLine_in_silkLine995 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_BlankLine_in_silkLine1000 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_WhiteSpace_in_silkLine1005 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_silkLine_in_silkFile956 = new BitSet(new long[]{0x0000000001790002L});
+    public static final BitSet FOLLOW_NodeIndent_in_silkLine977 = new BitSet(new long[]{0x0080200000000000L});
+    public static final BitSet FOLLOW_nodeItem_in_silkLine979 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_function_in_silkLine995 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_Preamble_in_silkLine1000 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_DataLine_in_silkLine1005 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_BlankLine_in_silkLine1010 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_WhiteSpace_in_silkLine1015 = new BitSet(new long[]{0x0000000000000002L});
     public static final BitSet FOLLOW_set_in_nodeName0 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_function_i_in_nodeValue1031 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_PlainOneLine_in_nodeValue1045 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_String_in_nodeValue1049 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_JSON_in_nodeValue1060 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_nodeName_in_nodeItem1071 = new BitSet(new long[]{0x00000016F2000002L});
-    public static final BitSet FOLLOW_dataType_in_nodeItem1073 = new BitSet(new long[]{0x00000012F2000002L});
-    public static final BitSet FOLLOW_Colon_in_nodeItem1077 = new BitSet(new long[]{0x0180200100000000L});
-    public static final BitSet FOLLOW_nodeValue_in_nodeItem1079 = new BitSet(new long[]{0x00000012E2000002L});
-    public static final BitSet FOLLOW_LParen_in_nodeItem1084 = new BitSet(new long[]{0x0080200000000000L});
-    public static final BitSet FOLLOW_attributeList_in_nodeItem1086 = new BitSet(new long[]{0x0000000004000000L});
-    public static final BitSet FOLLOW_RParen_in_nodeItem1088 = new BitSet(new long[]{0x00000012E0000002L});
-    public static final BitSet FOLLOW_plural_in_nodeItem1093 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_LBracket_in_dataType1123 = new BitSet(new long[]{0x0080000000000000L});
-    public static final BitSet FOLLOW_dataTypeName_in_dataType1126 = new BitSet(new long[]{0x0000000800000000L});
-    public static final BitSet FOLLOW_RBracket_in_dataType1128 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_PlainOneLine_in_dataTypeName1139 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_attributeItem_in_attributeList1157 = new BitSet(new long[]{0x0000000008000002L});
-    public static final BitSet FOLLOW_Comma_in_attributeList1160 = new BitSet(new long[]{0x0080200000000000L});
-    public static final BitSet FOLLOW_attributeItem_in_attributeList1163 = new BitSet(new long[]{0x0000000008000002L});
-    public static final BitSet FOLLOW_nodeItem_in_attributeItem1173 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_Star_in_plural1191 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_Plus_in_plural1201 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_Question_in_plural1211 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_Seq_in_plural1221 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_TabSeq_in_plural1231 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_NodeIndent_in_function1247 = new BitSet(new long[]{0x0000000100000000L});
-    public static final BitSet FOLLOW_function_i_in_function1249 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_FunctionIndent_in_function1265 = new BitSet(new long[]{0x0080000000000000L});
-    public static final BitSet FOLLOW_PlainOneLine_in_function1267 = new BitSet(new long[]{0x0000000002000000L});
-    public static final BitSet FOLLOW_LParen_in_function1269 = new BitSet(new long[]{0x0180200104000000L});
-    public static final BitSet FOLLOW_functionArg_in_function1272 = new BitSet(new long[]{0x000000000C000000L});
-    public static final BitSet FOLLOW_Comma_in_function1275 = new BitSet(new long[]{0x0180200100000000L});
-    public static final BitSet FOLLOW_functionArg_in_function1277 = new BitSet(new long[]{0x000000000C000000L});
-    public static final BitSet FOLLOW_RParen_in_function1283 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_At_in_function_i1309 = new BitSet(new long[]{0x0080000000000000L});
-    public static final BitSet FOLLOW_PlainOneLine_in_function_i1311 = new BitSet(new long[]{0x0000000002000000L});
-    public static final BitSet FOLLOW_LParen_in_function_i1313 = new BitSet(new long[]{0x0180200104000000L});
-    public static final BitSet FOLLOW_functionArg_in_function_i1316 = new BitSet(new long[]{0x000000000C000000L});
-    public static final BitSet FOLLOW_Comma_in_function_i1319 = new BitSet(new long[]{0x0180200100000000L});
-    public static final BitSet FOLLOW_functionArg_in_function_i1321 = new BitSet(new long[]{0x000000000C000000L});
-    public static final BitSet FOLLOW_RParen_in_function_i1327 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_nodeValue_in_functionArg1348 = new BitSet(new long[]{0x0000000000000002L});
-    public static final BitSet FOLLOW_nodeName_in_functionArg1358 = new BitSet(new long[]{0x0000000010000000L});
-    public static final BitSet FOLLOW_Colon_in_functionArg1360 = new BitSet(new long[]{0x0180200100000000L});
-    public static final BitSet FOLLOW_nodeValue_in_functionArg1362 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_function_i_in_nodeValue1041 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_PlainOneLine_in_nodeValue1055 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_String_in_nodeValue1059 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_JSON_in_nodeValue1070 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_nodeName_in_nodeItem1081 = new BitSet(new long[]{0x00000016F2000002L});
+    public static final BitSet FOLLOW_dataType_in_nodeItem1083 = new BitSet(new long[]{0x00000012F2000002L});
+    public static final BitSet FOLLOW_LParen_in_nodeItem1087 = new BitSet(new long[]{0x0080200000000000L});
+    public static final BitSet FOLLOW_attributeList_in_nodeItem1089 = new BitSet(new long[]{0x0000000004000000L});
+    public static final BitSet FOLLOW_RParen_in_nodeItem1091 = new BitSet(new long[]{0x00000012F0000002L});
+    public static final BitSet FOLLOW_plural_in_nodeItem1095 = new BitSet(new long[]{0x0000000010000002L});
+    public static final BitSet FOLLOW_Colon_in_nodeItem1099 = new BitSet(new long[]{0x0180200100000000L});
+    public static final BitSet FOLLOW_nodeValue_in_nodeItem1101 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_LBracket_in_dataType1133 = new BitSet(new long[]{0x0080000000000000L});
+    public static final BitSet FOLLOW_dataTypeName_in_dataType1136 = new BitSet(new long[]{0x0000000800000000L});
+    public static final BitSet FOLLOW_RBracket_in_dataType1138 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_PlainOneLine_in_dataTypeName1149 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_attributeItem_in_attributeList1167 = new BitSet(new long[]{0x0000000008000002L});
+    public static final BitSet FOLLOW_Comma_in_attributeList1170 = new BitSet(new long[]{0x0080200000000000L});
+    public static final BitSet FOLLOW_attributeItem_in_attributeList1173 = new BitSet(new long[]{0x0000000008000002L});
+    public static final BitSet FOLLOW_nodeItem_in_attributeItem1183 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_Star_in_plural1201 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_Plus_in_plural1211 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_Question_in_plural1221 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_Seq_in_plural1231 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_TabSeq_in_plural1241 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_NodeIndent_in_function1257 = new BitSet(new long[]{0x0000000100000000L});
+    public static final BitSet FOLLOW_function_i_in_function1259 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_FunctionIndent_in_function1275 = new BitSet(new long[]{0x0080000000000000L});
+    public static final BitSet FOLLOW_PlainOneLine_in_function1277 = new BitSet(new long[]{0x0000000002000000L});
+    public static final BitSet FOLLOW_LParen_in_function1279 = new BitSet(new long[]{0x0180200104000000L});
+    public static final BitSet FOLLOW_functionArg_in_function1282 = new BitSet(new long[]{0x000000000C000000L});
+    public static final BitSet FOLLOW_Comma_in_function1285 = new BitSet(new long[]{0x0180200100000000L});
+    public static final BitSet FOLLOW_functionArg_in_function1287 = new BitSet(new long[]{0x000000000C000000L});
+    public static final BitSet FOLLOW_RParen_in_function1293 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_At_in_function_i1319 = new BitSet(new long[]{0x0080000000000000L});
+    public static final BitSet FOLLOW_PlainOneLine_in_function_i1321 = new BitSet(new long[]{0x0000000002000000L});
+    public static final BitSet FOLLOW_LParen_in_function_i1323 = new BitSet(new long[]{0x0180200104000000L});
+    public static final BitSet FOLLOW_functionArg_in_function_i1326 = new BitSet(new long[]{0x000000000C000000L});
+    public static final BitSet FOLLOW_Comma_in_function_i1329 = new BitSet(new long[]{0x0180200100000000L});
+    public static final BitSet FOLLOW_functionArg_in_function_i1331 = new BitSet(new long[]{0x000000000C000000L});
+    public static final BitSet FOLLOW_RParen_in_function_i1337 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_nodeValue_in_functionArg1358 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_nodeName_in_functionArg1368 = new BitSet(new long[]{0x0000000010000000L});
+    public static final BitSet FOLLOW_Colon_in_functionArg1370 = new BitSet(new long[]{0x0180200100000000L});
+    public static final BitSet FOLLOW_nodeValue_in_functionArg1372 = new BitSet(new long[]{0x0000000000000002L});
 
 }
\ No newline at end of file
diff --git a/src/test/java/org/xerial/silk/SilkWalkerTest.java b/src/test/java/org/xerial/silk/SilkWalkerTest.java
index a72d97a..66f33f9 100644
--- a/src/test/java/org/xerial/silk/SilkWalkerTest.java
+++ b/src/test/java/org/xerial/silk/SilkWalkerTest.java
@@ -122,6 +122,12 @@ public class SilkWalkerTest
     }
 
     @Test
+    public void testBarChart() throws IOException, XerialException
+    {
+        compare("barchart.silk", "barchart.json");
+    }
+
+    @Test
     public void testExample() throws Exception
     {
         // TODO modify JSON stream walker to handle value as an immediate node value
diff --git a/src/test/java/org/xerial/silk/barchart.json b/src/test/java/org/xerial/silk/barchart.json
new file mode 100644
index 0000000..6ec5b88
--- /dev/null
+++ b/src/test/java/org/xerial/silk/barchart.json
@@ -0,0 +1,27 @@
+[
+ {"track":{"name":"Transcript Frequency"}},
+ {"barchart":
+  {
+  	"title":"bar chart",
+   	"yMin":0,
+ 	"yMax":100,
+ 	"xTitle": "genome position (bp)",
+ 	"yTitle": "number of transcripts (log scale)",
+ 	"yLogScale": true,
+  }
+ },
+ { "coordinate":
+    {
+     "group":"utgb", "species":"human", "revison":"hg18", "name":"chr1",
+ 	 "offsetX":1,
+	 "plot":[0,0,0,0,0,0,0,3,5,10,2,0,8,4,0,23,0,0,0,0]
+	}
+ },
+ { "coordinate":
+    {
+     "group":"utgb", "species":"human", "revison":"hg18", "name":"chr1",
+     "plot":[{"x":8, "y":3}, {"x":9, "y":5},
+        {"x":10, "y":10},{"x":11, "y":2},{"x":12, "y":8},{"x":13, "y":4}, {"x":15, "y":23}]
+    }
+ }
+] 
diff --git a/src/test/java/org/xerial/silk/barchart.silk b/src/test/java/org/xerial/silk/barchart.silk
new file mode 100644
index 0000000..978c24c
--- /dev/null
+++ b/src/test/java/org/xerial/silk/barchart.silk
@@ -0,0 +1,28 @@
+% silk(version:1.0)
+
+- track(name:"Transcript Frequency")
+
+- barchart
+ - title:bar chart
+ - yMin:0
+ - yMax :100
+ - xTitle : genome position (bp)
+ - yTitle : number of transcripts (log scale)
+ - yLogScale: true
+# plot y beginning from x=1 (offsetX = 1)
+- coordinate(group:utgb, species:human, revison:hg18, name:chr1)
+ - offsetX:1
+ - plot*
+0,0,0,0,0,0,0,3,5,10
+2,0,8,4,0,23,0,0,0,0
+
+# plot (x, y)
+- coordinate(group:utgb, species:human, revison:hg18, name:chr1)
+ - plot(x, y)|
+8	3
+9	5
+10	10
+11	2
+12	8
+13	4
+15	23
diff --git a/src/test/java/org/xerial/silk/impl/SilkLexerTest.java b/src/test/java/org/xerial/silk/impl/SilkLexerTest.java
index ae28342..fd6f4de 100644
--- a/src/test/java/org/xerial/silk/impl/SilkLexerTest.java
+++ b/src/test/java/org/xerial/silk/impl/SilkLexerTest.java
@@ -24,10 +24,12 @@
 //--------------------------------------
 package org.xerial.silk.impl;
 
+import java.io.IOException;
 import java.util.Map;
 
 import org.antlr.runtime.ANTLRReaderStream;
 import org.antlr.runtime.CommonTokenStream;
+import org.antlr.runtime.RecognitionException;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -48,6 +50,14 @@ public class SilkLexerTest
     public void tearDown() throws Exception
     {}
 
+    static void scan(String filePath) throws IOException, RecognitionException
+    {
+        SilkLexer lexer = new SilkLexer(new ANTLRReaderStream(FileResource.open(SilkParserTest.class, filePath)));
+        CommonTokenStream token = new CommonTokenStream(lexer);
+        Map<Integer, String> tokenTable = ANTLRUtil.getTokenTable(SilkLexer.class, "Silk.tokens");
+        _logger.debug("\n" + StringUtil.join(ANTLRUtil.prettyPrintTokenList(token.getTokens(), tokenTable), "\n"));
+    }
+
     @Test
     public void tokenTest() throws Exception
     {
@@ -61,4 +71,17 @@ public class SilkLexerTest
                 .debug("\n"
                         + StringUtil.join(ANTLRUtil.prettyPrintTokenList(tokenStream.getTokens(), tokenTable), "\n"));
     }
+
+    @Test
+    public void testOutValue() throws Exception
+    {
+        scan("outvalue.silk");
+    }
+
+    @Test
+    public void testBarChart() throws Exception
+    {
+        scan("../barchart.silk");
+    }
+
 }
diff --git a/src/test/java/org/xerial/silk/impl/outvalue.silk b/src/test/java/org/xerial/silk/impl/outvalue.silk
new file mode 100644
index 0000000..5b8bc6f
--- /dev/null
+++ b/src/test/java/org/xerial/silk/impl/outvalue.silk
@@ -0,0 +1 @@
+-value(id:1): hello (world!)