From 0dea6ff38903484e9911073dc50f384cbbf21f6c Mon Sep 17 00:00:00 2001
From: Kiyoshi Nakao <449732+ikehara@users.noreply.github.com>
Date: Tue, 30 Jul 2024 00:22:49 +0900
Subject: [PATCH] Fix quoting in set keyspace response and parsing of some
 identifier escapes (#127)

---
 parser/identifier.go |   14 +
 parser/lexer.go      | 4037 +++++++++++++++++++++---------------------
 parser/lexer.rl      |    2 +-
 parser/lexer_test.go |   35 +
 proxy/proxy.go       |    3 +-
 5 files changed, 2059 insertions(+), 2032 deletions(-)

diff --git a/parser/identifier.go b/parser/identifier.go
index cbace8b..f4aae9b 100644
--- a/parser/identifier.go
+++ b/parser/identifier.go
@@ -44,3 +44,17 @@ func (i Identifier) equal(id string) bool {
 func (i Identifier) isEmpty() bool {
 	return len(i.id) == 0
 }
+
+func (i Identifier) String() string {
+	if i.ignoreCase {
+		return i.id
+	}
+	return "\"" + i.id + "\""
+}
+
+func (i Identifier) ID() string {
+	if i.ignoreCase {
+		return strings.ToLower(i.id)
+	}
+	return strings.ReplaceAll(i.id, "\"\"", "\"")
+}
diff --git a/parser/lexer.go b/parser/lexer.go
index ba7815f..7b59f45 100644
--- a/parser/lexer.go
+++ b/parser/lexer.go
@@ -82,11 +82,11 @@ const (
 )
 
 //line lexer.go:88
-const lex_start int = 90
-const lex_first_final int = 90
+const lex_start int = 89
+const lex_first_final int = 89
 const lex_error int = -1
 
-const lex_en_main int = 90
+const lex_en_main int = 89
 
 //line lexer.rl:87
 
@@ -148,28 +148,28 @@ func (l *lexer) next() token {
 			goto _test_eof
 		}
 		switch cs {
+		case 89:
+			goto st_case_89
 		case 90:
 			goto st_case_90
 		case 91:
 			goto st_case_91
 		case 92:
 			goto st_case_92
-		case 93:
-			goto st_case_93
 		case 0:
 			goto st_case_0
-		case 1:
-			goto st_case_1
+		case 93:
+			goto st_case_93
 		case 94:
 			goto st_case_94
-		case 2:
-			goto st_case_2
+		case 1:
+			goto st_case_1
 		case 95:
 			goto st_case_95
 		case 96:
 			goto st_case_96
-		case 3:
-			goto st_case_3
+		case 2:
+			goto st_case_2
 		case 97:
 			goto st_case_97
 		case 98:
@@ -180,18 +180,20 @@ func (l *lexer) next() token {
 			goto st_case_100
 		case 101:
 			goto st_case_101
+		case 3:
+			goto st_case_3
 		case 4:
 			goto st_case_4
-		case 5:
-			goto st_case_5
 		case 102:
 			goto st_case_102
 		case 103:
 			goto st_case_103
-		case 6:
-			goto st_case_6
+		case 5:
+			goto st_case_5
 		case 104:
 			goto st_case_104
+		case 6:
+			goto st_case_6
 		case 7:
 			goto st_case_7
 		case 8:
@@ -212,10 +214,10 @@ func (l *lexer) next() token {
 			goto st_case_15
 		case 16:
 			goto st_case_16
-		case 17:
-			goto st_case_17
 		case 105:
 			goto st_case_105
+		case 17:
+			goto st_case_17
 		case 18:
 			goto st_case_18
 		case 19:
@@ -252,30 +254,28 @@ func (l *lexer) next() token {
 			goto st_case_34
 		case 35:
 			goto st_case_35
-		case 36:
-			goto st_case_36
 		case 106:
 			goto st_case_106
 		case 107:
 			goto st_case_107
-		case 37:
-			goto st_case_37
+		case 36:
+			goto st_case_36
 		case 108:
 			goto st_case_108
-		case 38:
-			goto st_case_38
+		case 37:
+			goto st_case_37
 		case 109:
 			goto st_case_109
-		case 39:
-			goto st_case_39
+		case 38:
+			goto st_case_38
 		case 110:
 			goto st_case_110
-		case 40:
-			goto st_case_40
+		case 39:
+			goto st_case_39
 		case 111:
 			goto st_case_111
-		case 41:
-			goto st_case_41
+		case 40:
+			goto st_case_40
 		case 112:
 			goto st_case_112
 		case 113:
@@ -292,6 +292,8 @@ func (l *lexer) next() token {
 			goto st_case_118
 		case 119:
 			goto st_case_119
+		case 41:
+			goto st_case_41
 		case 42:
 			goto st_case_42
 		case 43:
@@ -346,14 +348,12 @@ func (l *lexer) next() token {
 			goto st_case_67
 		case 68:
 			goto st_case_68
-		case 69:
-			goto st_case_69
 		case 120:
 			goto st_case_120
+		case 69:
+			goto st_case_69
 		case 70:
 			goto st_case_70
-		case 71:
-			goto st_case_71
 		case 121:
 			goto st_case_121
 		case 122:
@@ -362,64 +362,64 @@ func (l *lexer) next() token {
 			goto st_case_123
 		case 124:
 			goto st_case_124
-		case 72:
-			goto st_case_72
+		case 71:
+			goto st_case_71
 		case 125:
 			goto st_case_125
+		case 72:
+			goto st_case_72
 		case 73:
 			goto st_case_73
-		case 74:
-			goto st_case_74
 		case 126:
 			goto st_case_126
-		case 75:
-			goto st_case_75
+		case 74:
+			goto st_case_74
 		case 127:
 			goto st_case_127
+		case 75:
+			goto st_case_75
 		case 76:
 			goto st_case_76
-		case 77:
-			goto st_case_77
 		case 128:
 			goto st_case_128
-		case 78:
-			goto st_case_78
+		case 77:
+			goto st_case_77
 		case 129:
 			goto st_case_129
+		case 78:
+			goto st_case_78
 		case 79:
 			goto st_case_79
-		case 80:
-			goto st_case_80
 		case 130:
 			goto st_case_130
-		case 81:
-			goto st_case_81
+		case 80:
+			goto st_case_80
 		case 131:
 			goto st_case_131
+		case 81:
+			goto st_case_81
 		case 82:
 			goto st_case_82
-		case 83:
-			goto st_case_83
 		case 132:
 			goto st_case_132
-		case 84:
-			goto st_case_84
+		case 83:
+			goto st_case_83
 		case 133:
 			goto st_case_133
+		case 84:
+			goto st_case_84
 		case 85:
 			goto st_case_85
-		case 86:
-			goto st_case_86
 		case 134:
 			goto st_case_134
-		case 87:
-			goto st_case_87
+		case 86:
+			goto st_case_86
 		case 135:
 			goto st_case_135
+		case 87:
+			goto st_case_87
 		case 88:
 			goto st_case_88
-		case 89:
-			goto st_case_89
 		case 136:
 			goto st_case_136
 		case 137:
@@ -635,7 +635,7 @@ func (l *lexer) next() token {
 				tk = tkSelect
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -645,7 +645,7 @@ func (l *lexer) next() token {
 				tk = tkInsert
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -655,7 +655,7 @@ func (l *lexer) next() token {
 				tk = tkUpdate
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -665,7 +665,7 @@ func (l *lexer) next() token {
 				tk = tkDelete
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -675,7 +675,7 @@ func (l *lexer) next() token {
 				tk = tkBatch
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -685,7 +685,7 @@ func (l *lexer) next() token {
 				tk = tkBegin
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -695,7 +695,7 @@ func (l *lexer) next() token {
 				tk = tkApply
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -705,7 +705,7 @@ func (l *lexer) next() token {
 				tk = tkCreate
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -715,7 +715,7 @@ func (l *lexer) next() token {
 				tk = tkAlter
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -725,7 +725,7 @@ func (l *lexer) next() token {
 				tk = tkDrop
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -735,7 +735,7 @@ func (l *lexer) next() token {
 				tk = tkInto
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -745,7 +745,7 @@ func (l *lexer) next() token {
 				tk = tkFrom
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -755,7 +755,7 @@ func (l *lexer) next() token {
 				tk = tkUse
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -765,7 +765,7 @@ func (l *lexer) next() token {
 				tk = tkUsing
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -775,7 +775,7 @@ func (l *lexer) next() token {
 				tk = tkIf
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -785,7 +785,7 @@ func (l *lexer) next() token {
 				tk = tkWhere
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -795,7 +795,7 @@ func (l *lexer) next() token {
 				tk = tkAnd
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -805,7 +805,7 @@ func (l *lexer) next() token {
 				tk = tkIs
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -815,7 +815,7 @@ func (l *lexer) next() token {
 				tk = tkNot
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -825,7 +825,7 @@ func (l *lexer) next() token {
 				tk = tkToken
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -835,7 +835,7 @@ func (l *lexer) next() token {
 				tk = tkBool
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -845,7 +845,7 @@ func (l *lexer) next() token {
 				tk = tkNull
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -855,7 +855,7 @@ func (l *lexer) next() token {
 				tk = tkNan
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -865,7 +865,7 @@ func (l *lexer) next() token {
 				tk = tkInfinity
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -875,7 +875,7 @@ func (l *lexer) next() token {
 				tk = tkStringLiteral
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -885,7 +885,7 @@ func (l *lexer) next() token {
 				tk = tkInteger
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -895,7 +895,7 @@ func (l *lexer) next() token {
 				tk = tkFloat
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -905,7 +905,7 @@ func (l *lexer) next() token {
 				tk = tkDuration
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -916,7 +916,7 @@ func (l *lexer) next() token {
 				l.id = l.data[ts:te]
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
@@ -926,291 +926,278 @@ func (l *lexer) next() token {
 				tk = tkInvalid
 				{
 					p++
-					cs = 90
+					cs = 89
 					goto _out
 				}
 			}
 		}
 
-		goto st90
-	tr2:
-//line lexer.rl:204
-		te = p + 1
-		{
-			tk = tkIdentifier
-			l.id = l.data[ts:te]
-			{
-				p++
-				cs = 90
-				goto _out
-			}
-		}
-		goto st90
-	tr11:
+		goto st89
+	tr9:
 //line lexer.rl:202
 		p = (te) - 1
 		{
 			tk = tkDuration
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr17:
+		goto st89
+	tr15:
 //line lexer.rl:192
 		p = (te) - 1
 		{
 			tk = tkSub
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr24:
+		goto st89
+	tr22:
 //line lexer.rl:196
 		te = p + 1
 		{
 			tk = tkInfinity
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr26:
+		goto st89
+	tr24:
 //line lexer.rl:195
 		te = p + 1
 		{
 			tk = tkNan
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr30:
+		goto st89
+	tr28:
 //line lexer.rl:202
 		te = p + 1
 		{
 			tk = tkDuration
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr82:
+		goto st89
+	tr80:
 //line lexer.rl:203
 		te = p + 1
 		{
 			tk = tkUuid
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr84:
+		goto st89
+	tr82:
 //line lexer.rl:199
 		p = (te) - 1
 		{
 			tk = tkInteger
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr109:
+		goto st89
+	tr107:
 //line lexer.rl:207
 		te = p + 1
 		{
 			tk = tkInvalid
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr110:
+		goto st89
+	tr108:
 //line lexer.rl:206
 		te = p + 1
 		{ /* Skip */
 		}
-		goto st90
-	tr111:
+		goto st89
+	tr109:
 //line lexer.rl:205
 		te = p + 1
 		{ /* Skip */
 		}
-		goto st90
-	tr117:
+		goto st89
+	tr115:
 //line lexer.rl:179
 		te = p + 1
 		{
 			tk = tkLparen
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr118:
+		goto st89
+	tr116:
 //line lexer.rl:180
 		te = p + 1
 		{
 			tk = tkRparen
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr119:
+		goto st89
+	tr117:
 //line lexer.rl:174
 		te = p + 1
 		{
 			tk = tkStar
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr121:
+		goto st89
+	tr119:
 //line lexer.rl:175
 		te = p + 1
 		{
 			tk = tkComma
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr123:
+		goto st89
+	tr121:
 //line lexer.rl:176
 		te = p + 1
 		{
 			tk = tkDot
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr126:
+		goto st89
+	tr124:
 //line lexer.rl:177
 		te = p + 1
 		{
 			tk = tkColon
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr127:
+		goto st89
+	tr125:
 //line lexer.rl:197
 		te = p + 1
 		{
 			tk = tkEOS
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr129:
+		goto st89
+	tr127:
 //line lexer.rl:185
 		te = p + 1
 		{
 			tk = tkEqual
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr131:
+		goto st89
+	tr129:
 //line lexer.rl:178
 		te = p + 1
 		{
 			tk = tkQMark
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr146:
+		goto st89
+	tr144:
 //line lexer.rl:181
 		te = p + 1
 		{
 			tk = tkLsquare
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr147:
+		goto st89
+	tr145:
 //line lexer.rl:182
 		te = p + 1
 		{
 			tk = tkRsquare
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr148:
+		goto st89
+	tr146:
 //line lexer.rl:183
 		te = p + 1
 		{
 			tk = tkLcurly
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr149:
+		goto st89
+	tr147:
 //line lexer.rl:184
 		te = p + 1
 		{
 			tk = tkRcurly
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr150:
+		goto st89
+	tr148:
 //line lexer.rl:207
 		te = p
 		p--
@@ -1218,24 +1205,38 @@ func (l *lexer) next() token {
 			tk = tkInvalid
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr151:
+		goto st89
+	tr149:
 //line lexer.rl:190
 		te = p + 1
 		{
 			tk = tkNotEqual
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr152:
+		goto st89
+	tr150:
+//line lexer.rl:204
+		te = p
+		p--
+		{
+			tk = tkIdentifier
+			l.id = l.data[ts:te]
+			{
+				p++
+				cs = 89
+				goto _out
+			}
+		}
+		goto st89
+	tr151:
 //line lexer.rl:198
 		te = p
 		p--
@@ -1243,12 +1244,12 @@ func (l *lexer) next() token {
 			tk = tkStringLiteral
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr153:
+		goto st89
+	tr152:
 //line lexer.rl:191
 		te = p
 		p--
@@ -1256,24 +1257,24 @@ func (l *lexer) next() token {
 			tk = tkAdd
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr154:
+		goto st89
+	tr153:
 //line lexer.rl:193
 		te = p + 1
 		{
 			tk = tkAddEqual
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr155:
+		goto st89
+	tr154:
 //line lexer.rl:192
 		te = p
 		p--
@@ -1281,24 +1282,24 @@ func (l *lexer) next() token {
 			tk = tkSub
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr157:
+		goto st89
+	tr156:
 //line lexer.rl:194
 		te = p + 1
 		{
 			tk = tkSubEqual
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr161:
+		goto st89
+	tr160:
 //line lexer.rl:199
 		te = p
 		p--
@@ -1306,12 +1307,12 @@ func (l *lexer) next() token {
 			tk = tkInteger
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr164:
+		goto st89
+	tr163:
 //line lexer.rl:200
 		te = p
 		p--
@@ -1319,12 +1320,12 @@ func (l *lexer) next() token {
 			tk = tkFloat
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr165:
+		goto st89
+	tr164:
 //line lexer.rl:202
 		te = p
 		p--
@@ -1332,12 +1333,12 @@ func (l *lexer) next() token {
 			tk = tkDuration
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr190:
+		goto st89
+	tr189:
 //line lexer.rl:201
 		te = p
 		p--
@@ -1345,12 +1346,12 @@ func (l *lexer) next() token {
 			tk = tkHexNumber
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr191:
+		goto st89
+	tr190:
 //line lexer.rl:188
 		te = p
 		p--
@@ -1358,24 +1359,24 @@ func (l *lexer) next() token {
 			tk = tkLt
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr192:
+		goto st89
+	tr191:
 //line lexer.rl:186
 		te = p + 1
 		{
 			tk = tkLtEqual
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr193:
+		goto st89
+	tr192:
 //line lexer.rl:189
 		te = p
 		p--
@@ -1383,38 +1384,24 @@ func (l *lexer) next() token {
 			tk = tkGt
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr194:
+		goto st89
+	tr193:
 //line lexer.rl:187
 		te = p + 1
 		{
 			tk = tkGtEqual
 			{
 				p++
-				cs = 90
-				goto _out
-			}
-		}
-		goto st90
-	tr195:
-//line lexer.rl:204
-		te = p
-		p--
-		{
-			tk = tkIdentifier
-			l.id = l.data[ts:te]
-			{
-				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	tr244:
+		goto st89
+	tr242:
 //line lexer.rl:169
 		te = p
 		p--
@@ -1422,68 +1409,68 @@ func (l *lexer) next() token {
 			tk = tkIn
 			{
 				p++
-				cs = 90
+				cs = 89
 				goto _out
 			}
 		}
-		goto st90
-	st90:
+		goto st89
+	st89:
 //line NONE:1
 		ts = 0
 
 		if p++; p == pe {
-			goto _test_eof90
+			goto _test_eof89
 		}
-	st_case_90:
+	st_case_89:
 //line NONE:1
 		ts = p
 
-//line lexer.go:960
+//line lexer.go:955
 		switch data[p] {
 		case 9:
-			goto tr110
+			goto tr108
 		case 10:
-			goto tr111
+			goto tr109
 		case 13:
-			goto st91
+			goto st90
 		case 32:
-			goto tr110
+			goto tr108
 		case 33:
-			goto st92
+			goto st91
 		case 34:
-			goto tr114
+			goto tr112
 		case 36:
-			goto tr115
+			goto tr113
 		case 39:
-			goto tr116
+			goto tr114
 		case 40:
-			goto tr117
+			goto tr115
 		case 41:
-			goto tr118
+			goto tr116
 		case 42:
-			goto tr119
+			goto tr117
 		case 43:
 			goto st98
 		case 44:
-			goto tr121
+			goto tr119
 		case 45:
-			goto tr122
+			goto tr120
 		case 46:
-			goto tr123
+			goto tr121
 		case 48:
-			goto tr124
+			goto tr122
 		case 58:
-			goto tr126
+			goto tr124
 		case 59:
-			goto tr127
+			goto tr125
 		case 60:
 			goto st139
 		case 61:
-			goto tr129
+			goto tr127
 		case 62:
 			goto st140
 		case 63:
-			goto tr131
+			goto tr129
 		case 65:
 			goto st141
 		case 66:
@@ -1511,9 +1498,9 @@ func (l *lexer) next() token {
 		case 87:
 			goto st234
 		case 91:
-			goto tr146
+			goto tr144
 		case 93:
-			goto tr147
+			goto tr145
 		case 97:
 			goto st141
 		case 98:
@@ -1539,70 +1526,61 @@ func (l *lexer) next() token {
 		case 119:
 			goto st234
 		case 123:
-			goto tr148
+			goto tr146
 		case 125:
-			goto tr149
+			goto tr147
 		}
 		switch {
 		case data[p] < 71:
 			if 49 <= data[p] && data[p] <= 57 {
-				goto tr125
+				goto tr123
 			}
 		case data[p] > 90:
 			if 103 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr109
-	st91:
+		goto tr107
+	st90:
 		if p++; p == pe {
-			goto _test_eof91
+			goto _test_eof90
 		}
-	st_case_91:
+	st_case_90:
 		if data[p] == 10 {
-			goto tr111
+			goto tr109
 		}
-		goto tr150
-	st92:
+		goto tr148
+	st91:
 		if p++; p == pe {
-			goto _test_eof92
+			goto _test_eof91
 		}
-	st_case_92:
+	st_case_91:
 		if data[p] == 61 {
-			goto tr151
+			goto tr149
 		}
-		goto tr150
-	tr4:
-//line NONE:1
-		te = p + 1
-
-//line lexer.rl:204
-		act = 54
-		goto st93
-	tr114:
+		goto tr148
+	tr112:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:207
 		act = 57
-		goto st93
-	st93:
+		goto st92
+	st92:
 		if p++; p == pe {
-			goto _test_eof93
+			goto _test_eof92
 		}
-	st_case_93:
-//line lexer.go:1115
+	st_case_92:
+//line lexer.go:1103
 		switch data[p] {
 		case 10:
-			goto tr0
+			goto tr148
 		case 13:
-			goto tr0
+			goto tr148
 		case 34:
 			goto tr2
-		case 92:
-			goto st1
 		}
 		goto st0
 	st0:
@@ -1617,27 +1595,26 @@ func (l *lexer) next() token {
 			goto tr0
 		case 34:
 			goto tr2
-		case 92:
-			goto st1
 		}
 		goto st0
-	st1:
+	tr2:
+//line NONE:1
+		te = p + 1
+
+//line lexer.rl:204
+		act = 54
+		goto st93
+	st93:
 		if p++; p == pe {
-			goto _test_eof1
+			goto _test_eof93
 		}
-	st_case_1:
-		switch data[p] {
-		case 10:
-			goto tr0
-		case 13:
-			goto tr0
-		case 34:
-			goto tr4
-		case 92:
-			goto st1
+	st_case_93:
+//line lexer.go:1139
+		if data[p] == 34 {
+			goto st0
 		}
-		goto st0
-	tr115:
+		goto tr150
+	tr113:
 //line NONE:1
 		te = p + 1
 
@@ -1649,21 +1626,21 @@ func (l *lexer) next() token {
 			goto _test_eof94
 		}
 	st_case_94:
-//line lexer.go:1171
+//line lexer.go:1156
 		if data[p] == 36 {
-			goto tr6
+			goto tr4
 		}
-		goto st2
-	st2:
+		goto st1
+	st1:
 		if p++; p == pe {
-			goto _test_eof2
+			goto _test_eof1
 		}
-	st_case_2:
+	st_case_1:
 		if data[p] == 36 {
-			goto tr6
+			goto tr4
 		}
-		goto st2
-	tr6:
+		goto st1
+	tr4:
 //line NONE:1
 		te = p + 1
 
@@ -1675,12 +1652,12 @@ func (l *lexer) next() token {
 			goto _test_eof95
 		}
 	st_case_95:
-//line lexer.go:1197
+//line lexer.go:1182
 		if data[p] == 36 {
-			goto st2
+			goto st1
 		}
-		goto tr152
-	tr116:
+		goto tr151
+	tr114:
 //line NONE:1
 		te = p + 1
 
@@ -1692,21 +1669,21 @@ func (l *lexer) next() token {
 			goto _test_eof96
 		}
 	st_case_96:
-//line lexer.go:1214
+//line lexer.go:1199
 		if data[p] == 39 {
-			goto tr8
+			goto tr6
 		}
-		goto st3
-	st3:
+		goto st2
+	st2:
 		if p++; p == pe {
-			goto _test_eof3
+			goto _test_eof2
 		}
-	st_case_3:
+	st_case_2:
 		if data[p] == 39 {
-			goto tr8
+			goto tr6
 		}
-		goto st3
-	tr8:
+		goto st2
+	tr6:
 //line NONE:1
 		te = p + 1
 
@@ -1718,21 +1695,21 @@ func (l *lexer) next() token {
 			goto _test_eof97
 		}
 	st_case_97:
-//line lexer.go:1240
+//line lexer.go:1225
 		if data[p] == 39 {
-			goto st3
+			goto st2
 		}
-		goto tr152
+		goto tr151
 	st98:
 		if p++; p == pe {
 			goto _test_eof98
 		}
 	st_case_98:
 		if data[p] == 61 {
-			goto tr154
+			goto tr153
 		}
-		goto tr153
-	tr122:
+		goto tr152
+	tr120:
 //line NONE:1
 		te = p + 1
 
@@ -1742,26 +1719,26 @@ func (l *lexer) next() token {
 			goto _test_eof99
 		}
 	st_case_99:
-//line lexer.go:1264
+//line lexer.go:1249
 		switch data[p] {
 		case 61:
-			goto tr157
+			goto tr156
 		case 73:
-			goto st9
+			goto st8
 		case 78:
-			goto st16
+			goto st15
 		case 80:
-			goto tr160
+			goto tr159
 		case 105:
-			goto st9
+			goto st8
 		case 110:
-			goto st16
+			goto st15
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto tr156
+			goto tr155
 		}
-		goto tr155
-	tr156:
+		goto tr154
+	tr155:
 //line NONE:1
 		te = p + 1
 
@@ -1773,54 +1750,54 @@ func (l *lexer) next() token {
 			goto _test_eof100
 		}
 	st_case_100:
-//line lexer.go:1295
+//line lexer.go:1280
 		switch data[p] {
 		case 46:
-			goto tr162
+			goto tr161
 		case 68:
-			goto tr13
+			goto tr11
 		case 69:
-			goto st4
+			goto st3
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr13
+			goto tr11
 		case 101:
-			goto st4
+			goto st3
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto tr156
+			goto tr155
 		}
-		goto tr161
-	tr162:
+		goto tr160
+	tr161:
 //line NONE:1
 		te = p + 1
 
@@ -1832,37 +1809,37 @@ func (l *lexer) next() token {
 			goto _test_eof101
 		}
 	st_case_101:
-//line lexer.go:1354
+//line lexer.go:1339
 		switch data[p] {
 		case 69:
-			goto st4
+			goto st3
 		case 101:
-			goto st4
+			goto st3
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto tr162
+			goto tr161
 		}
-		goto tr164
-	st4:
+		goto tr163
+	st3:
 		if p++; p == pe {
-			goto _test_eof4
+			goto _test_eof3
 		}
-	st_case_4:
+	st_case_3:
 		switch data[p] {
 		case 43:
-			goto st5
+			goto st4
 		case 45:
-			goto st5
+			goto st4
 		}
 		if 48 <= data[p] && data[p] <= 57 {
 			goto st102
 		}
 		goto tr0
-	st5:
+	st4:
 		if p++; p == pe {
-			goto _test_eof5
+			goto _test_eof4
 		}
-	st_case_5:
+	st_case_4:
 		if 48 <= data[p] && data[p] <= 57 {
 			goto st102
 		}
@@ -1875,8 +1852,8 @@ func (l *lexer) next() token {
 		if 48 <= data[p] && data[p] <= 57 {
 			goto st102
 		}
-		goto tr164
-	tr13:
+		goto tr163
+	tr11:
 //line NONE:1
 		te = p + 1
 
@@ -1888,57 +1865,57 @@ func (l *lexer) next() token {
 			goto _test_eof103
 		}
 	st_case_103:
-//line lexer.go:1410
+//line lexer.go:1395
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st6
+			goto st5
 		}
-		goto tr165
-	st6:
+		goto tr164
+	st5:
 		if p++; p == pe {
-			goto _test_eof6
+			goto _test_eof5
 		}
-	st_case_6:
+	st_case_5:
 		switch data[p] {
 		case 68:
-			goto tr13
+			goto tr11
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr13
+			goto tr11
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st6
+			goto st5
 		}
-		goto tr11
-	tr14:
+		goto tr9
+	tr12:
 //line NONE:1
 		te = p + 1
 
@@ -1950,31 +1927,40 @@ func (l *lexer) next() token {
 			goto _test_eof104
 		}
 	st_case_104:
-//line lexer.go:1472
+//line lexer.go:1457
 		switch data[p] {
 		case 79:
-			goto tr13
+			goto tr11
 		case 83:
-			goto tr13
+			goto tr11
 		case 111:
-			goto tr13
+			goto tr11
 		case 115:
-			goto tr13
+			goto tr11
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st6
+			goto st5
 		}
-		goto tr165
-	st7:
+		goto tr164
+	st6:
 		if p++; p == pe {
-			goto _test_eof7
+			goto _test_eof6
 		}
-	st_case_7:
+	st_case_6:
 		switch data[p] {
 		case 83:
-			goto tr13
+			goto tr11
 		case 115:
-			goto tr13
+			goto tr11
+		}
+		goto tr0
+	st7:
+		if p++; p == pe {
+			goto _test_eof7
+		}
+	st_case_7:
+		if data[p] == 181 {
+			goto st6
 		}
 		goto tr0
 	st8:
@@ -1982,119 +1968,110 @@ func (l *lexer) next() token {
 			goto _test_eof8
 		}
 	st_case_8:
-		if data[p] == 181 {
-			goto st7
+		switch data[p] {
+		case 78:
+			goto st9
+		case 110:
+			goto st9
 		}
-		goto tr0
+		goto tr15
 	st9:
 		if p++; p == pe {
 			goto _test_eof9
 		}
 	st_case_9:
 		switch data[p] {
-		case 78:
+		case 70:
 			goto st10
-		case 110:
+		case 102:
 			goto st10
 		}
-		goto tr17
+		goto tr15
 	st10:
 		if p++; p == pe {
 			goto _test_eof10
 		}
 	st_case_10:
 		switch data[p] {
-		case 70:
+		case 73:
 			goto st11
-		case 102:
+		case 105:
 			goto st11
 		}
-		goto tr17
+		goto tr15
 	st11:
 		if p++; p == pe {
 			goto _test_eof11
 		}
 	st_case_11:
 		switch data[p] {
-		case 73:
+		case 78:
 			goto st12
-		case 105:
+		case 110:
 			goto st12
 		}
-		goto tr17
+		goto tr15
 	st12:
 		if p++; p == pe {
 			goto _test_eof12
 		}
 	st_case_12:
 		switch data[p] {
-		case 78:
+		case 73:
 			goto st13
-		case 110:
+		case 105:
 			goto st13
 		}
-		goto tr17
+		goto tr15
 	st13:
 		if p++; p == pe {
 			goto _test_eof13
 		}
 	st_case_13:
 		switch data[p] {
-		case 73:
+		case 84:
 			goto st14
-		case 105:
+		case 116:
 			goto st14
 		}
-		goto tr17
+		goto tr15
 	st14:
 		if p++; p == pe {
 			goto _test_eof14
 		}
 	st_case_14:
 		switch data[p] {
-		case 84:
-			goto st15
-		case 116:
-			goto st15
+		case 89:
+			goto tr22
+		case 121:
+			goto tr22
 		}
-		goto tr17
+		goto tr15
 	st15:
 		if p++; p == pe {
 			goto _test_eof15
 		}
 	st_case_15:
 		switch data[p] {
-		case 89:
-			goto tr24
-		case 121:
-			goto tr24
+		case 65:
+			goto st16
+		case 97:
+			goto st16
 		}
-		goto tr17
+		goto tr15
 	st16:
 		if p++; p == pe {
 			goto _test_eof16
 		}
 	st_case_16:
-		switch data[p] {
-		case 65:
-			goto st17
-		case 97:
-			goto st17
-		}
-		goto tr17
-	st17:
-		if p++; p == pe {
-			goto _test_eof17
-		}
-	st_case_17:
 		switch data[p] {
 		case 78:
-			goto tr26
+			goto tr24
 		case 110:
-			goto tr26
+			goto tr24
 		}
-		goto tr17
-	tr160:
+		goto tr15
+	tr159:
 //line NONE:1
 		te = p + 1
 
@@ -2106,14 +2083,33 @@ func (l *lexer) next() token {
 			goto _test_eof105
 		}
 	st_case_105:
-//line lexer.go:1628
+//line lexer.go:1613
 		if data[p] == 84 {
-			goto tr167
+			goto tr166
+		}
+		if 48 <= data[p] && data[p] <= 57 {
+			goto st17
+		}
+		goto tr164
+	st17:
+		if p++; p == pe {
+			goto _test_eof17
+		}
+	st_case_17:
+		switch data[p] {
+		case 68:
+			goto st106
+		case 77:
+			goto tr27
+		case 87:
+			goto tr28
+		case 89:
+			goto tr29
 		}
 		if 48 <= data[p] && data[p] <= 57 {
 			goto st18
 		}
-		goto tr165
+		goto tr9
 	st18:
 		if p++; p == pe {
 			goto _test_eof18
@@ -2123,16 +2119,16 @@ func (l *lexer) next() token {
 		case 68:
 			goto st106
 		case 77:
-			goto tr29
+			goto tr27
 		case 87:
-			goto tr30
+			goto tr28
 		case 89:
-			goto tr31
+			goto tr29
 		}
 		if 48 <= data[p] && data[p] <= 57 {
 			goto st19
 		}
-		goto tr11
+		goto tr9
 	st19:
 		if p++; p == pe {
 			goto _test_eof19
@@ -2142,56 +2138,46 @@ func (l *lexer) next() token {
 		case 68:
 			goto st106
 		case 77:
-			goto tr29
+			goto tr27
 		case 87:
-			goto tr30
+			goto tr28
 		case 89:
-			goto tr31
+			goto tr29
 		}
 		if 48 <= data[p] && data[p] <= 57 {
 			goto st20
 		}
-		goto tr11
+		goto tr9
 	st20:
 		if p++; p == pe {
 			goto _test_eof20
 		}
 	st_case_20:
 		switch data[p] {
+		case 45:
+			goto st21
 		case 68:
 			goto st106
 		case 77:
-			goto tr29
+			goto tr27
 		case 87:
-			goto tr30
+			goto tr28
 		case 89:
-			goto tr31
+			goto tr29
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st21
+			goto st35
 		}
-		goto tr11
+		goto tr9
 	st21:
 		if p++; p == pe {
 			goto _test_eof21
 		}
 	st_case_21:
-		switch data[p] {
-		case 45:
-			goto st22
-		case 68:
-			goto st106
-		case 77:
-			goto tr29
-		case 87:
-			goto tr30
-		case 89:
-			goto tr31
-		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st36
+			goto st22
 		}
-		goto tr11
+		goto tr0
 	st22:
 		if p++; p == pe {
 			goto _test_eof22
@@ -2206,7 +2192,7 @@ func (l *lexer) next() token {
 			goto _test_eof23
 		}
 	st_case_23:
-		if 48 <= data[p] && data[p] <= 57 {
+		if data[p] == 45 {
 			goto st24
 		}
 		goto tr0
@@ -2215,7 +2201,7 @@ func (l *lexer) next() token {
 			goto _test_eof24
 		}
 	st_case_24:
-		if data[p] == 45 {
+		if 48 <= data[p] && data[p] <= 57 {
 			goto st25
 		}
 		goto tr0
@@ -2233,7 +2219,7 @@ func (l *lexer) next() token {
 			goto _test_eof26
 		}
 	st_case_26:
-		if 48 <= data[p] && data[p] <= 57 {
+		if data[p] == 84 {
 			goto st27
 		}
 		goto tr0
@@ -2242,7 +2228,7 @@ func (l *lexer) next() token {
 			goto _test_eof27
 		}
 	st_case_27:
-		if data[p] == 84 {
+		if 48 <= data[p] && data[p] <= 57 {
 			goto st28
 		}
 		goto tr0
@@ -2260,7 +2246,7 @@ func (l *lexer) next() token {
 			goto _test_eof29
 		}
 	st_case_29:
-		if 48 <= data[p] && data[p] <= 57 {
+		if data[p] == 58 {
 			goto st30
 		}
 		goto tr0
@@ -2269,7 +2255,7 @@ func (l *lexer) next() token {
 			goto _test_eof30
 		}
 	st_case_30:
-		if data[p] == 58 {
+		if 48 <= data[p] && data[p] <= 57 {
 			goto st31
 		}
 		goto tr0
@@ -2287,7 +2273,7 @@ func (l *lexer) next() token {
 			goto _test_eof32
 		}
 	st_case_32:
-		if 48 <= data[p] && data[p] <= 57 {
+		if data[p] == 58 {
 			goto st33
 		}
 		goto tr0
@@ -2296,7 +2282,7 @@ func (l *lexer) next() token {
 			goto _test_eof33
 		}
 	st_case_33:
-		if data[p] == 58 {
+		if 48 <= data[p] && data[p] <= 57 {
 			goto st34
 		}
 		goto tr0
@@ -2306,7 +2292,7 @@ func (l *lexer) next() token {
 		}
 	st_case_34:
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st35
+			goto tr28
 		}
 		goto tr0
 	st35:
@@ -2314,39 +2300,30 @@ func (l *lexer) next() token {
 			goto _test_eof35
 		}
 	st_case_35:
-		if 48 <= data[p] && data[p] <= 57 {
-			goto tr30
-		}
-		goto tr0
-	st36:
-		if p++; p == pe {
-			goto _test_eof36
-		}
-	st_case_36:
 		switch data[p] {
 		case 68:
 			goto st106
 		case 77:
-			goto tr29
+			goto tr27
 		case 87:
-			goto tr30
+			goto tr28
 		case 89:
-			goto tr31
+			goto tr29
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st36
+			goto st35
 		}
-		goto tr11
+		goto tr9
 	st106:
 		if p++; p == pe {
 			goto _test_eof106
 		}
 	st_case_106:
 		if data[p] == 84 {
-			goto tr167
+			goto tr166
 		}
-		goto tr165
-	tr167:
+		goto tr164
+	tr166:
 //line NONE:1
 		te = p + 1
 
@@ -2356,29 +2333,29 @@ func (l *lexer) next() token {
 			goto _test_eof107
 		}
 	st_case_107:
-//line lexer.go:1878
+//line lexer.go:1863
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st37
+			goto st36
 		}
-		goto tr165
-	st37:
+		goto tr164
+	st36:
 		if p++; p == pe {
-			goto _test_eof37
+			goto _test_eof36
 		}
-	st_case_37:
+	st_case_36:
 		switch data[p] {
 		case 72:
-			goto tr50
+			goto tr48
 		case 77:
-			goto tr51
+			goto tr49
 		case 83:
-			goto tr30
+			goto tr28
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st37
+			goto st36
 		}
-		goto tr11
-	tr50:
+		goto tr9
+	tr48:
 //line NONE:1
 		te = p + 1
 
@@ -2388,27 +2365,27 @@ func (l *lexer) next() token {
 			goto _test_eof108
 		}
 	st_case_108:
-//line lexer.go:1910
+//line lexer.go:1895
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st38
+			goto st37
 		}
-		goto tr165
-	st38:
+		goto tr164
+	st37:
 		if p++; p == pe {
-			goto _test_eof38
+			goto _test_eof37
 		}
-	st_case_38:
+	st_case_37:
 		switch data[p] {
 		case 77:
-			goto tr51
+			goto tr49
 		case 83:
-			goto tr30
+			goto tr28
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st38
+			goto st37
 		}
-		goto tr11
-	tr51:
+		goto tr9
+	tr49:
 //line NONE:1
 		te = p + 1
 
@@ -2418,24 +2395,24 @@ func (l *lexer) next() token {
 			goto _test_eof109
 		}
 	st_case_109:
-//line lexer.go:1940
+//line lexer.go:1925
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st39
+			goto st38
 		}
-		goto tr165
-	st39:
+		goto tr164
+	st38:
 		if p++; p == pe {
-			goto _test_eof39
+			goto _test_eof38
 		}
-	st_case_39:
+	st_case_38:
 		if data[p] == 83 {
-			goto tr30
+			goto tr28
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st39
+			goto st38
 		}
-		goto tr11
-	tr29:
+		goto tr9
+	tr27:
 //line NONE:1
 		te = p + 1
 
@@ -2445,27 +2422,27 @@ func (l *lexer) next() token {
 			goto _test_eof110
 		}
 	st_case_110:
-//line lexer.go:1967
+//line lexer.go:1952
 		if data[p] == 84 {
-			goto tr167
+			goto tr166
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st40
+			goto st39
 		}
-		goto tr165
-	st40:
+		goto tr164
+	st39:
 		if p++; p == pe {
-			goto _test_eof40
+			goto _test_eof39
 		}
-	st_case_40:
+	st_case_39:
 		if data[p] == 68 {
 			goto st106
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st40
+			goto st39
 		}
-		goto tr11
-	tr31:
+		goto tr9
+	tr29:
 //line NONE:1
 		te = p + 1
 
@@ -2475,30 +2452,30 @@ func (l *lexer) next() token {
 			goto _test_eof111
 		}
 	st_case_111:
-//line lexer.go:1997
+//line lexer.go:1982
 		if data[p] == 84 {
-			goto tr167
+			goto tr166
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st41
+			goto st40
 		}
-		goto tr165
-	st41:
+		goto tr164
+	st40:
 		if p++; p == pe {
-			goto _test_eof41
+			goto _test_eof40
 		}
-	st_case_41:
+	st_case_40:
 		switch data[p] {
 		case 68:
 			goto st106
 		case 77:
-			goto tr29
+			goto tr27
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st41
+			goto st40
 		}
-		goto tr11
-	tr124:
+		goto tr9
+	tr122:
 //line NONE:1
 		te = p + 1
 
@@ -2510,69 +2487,69 @@ func (l *lexer) next() token {
 			goto _test_eof112
 		}
 	st_case_112:
-//line lexer.go:2032
+//line lexer.go:2017
 		switch data[p] {
 		case 46:
-			goto tr162
+			goto tr161
 		case 68:
-			goto tr170
+			goto tr169
 		case 69:
-			goto st89
+			goto st88
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 88:
 			goto st137
 		case 100:
-			goto tr170
+			goto tr169
 		case 101:
-			goto st89
+			goto st88
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 120:
 			goto st137
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 87:
 			switch {
 			case data[p] > 57:
 				if 65 <= data[p] && data[p] <= 70 {
-					goto st87
+					goto st86
 				}
 			case data[p] >= 48:
-				goto tr168
+				goto tr167
 			}
 		case data[p] > 89:
 			switch {
 			case data[p] > 102:
 				if 119 <= data[p] && data[p] <= 121 {
-					goto tr13
+					goto tr11
 				}
 			case data[p] >= 97:
-				goto st87
+				goto st86
 			}
 		default:
-			goto tr13
+			goto tr11
 		}
-		goto tr161
-	tr168:
+		goto tr160
+	tr167:
 //line NONE:1
 		te = p + 1
 
@@ -2584,63 +2561,63 @@ func (l *lexer) next() token {
 			goto _test_eof113
 		}
 	st_case_113:
-//line lexer.go:2106
+//line lexer.go:2091
 		switch data[p] {
 		case 46:
-			goto tr162
+			goto tr161
 		case 68:
-			goto tr174
+			goto tr173
 		case 69:
-			goto st86
+			goto st85
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr174
+			goto tr173
 		case 101:
-			goto st86
+			goto st85
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr173
+				goto tr172
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st84
+				goto st83
 			}
 		default:
-			goto st84
+			goto st83
 		}
-		goto tr161
-	tr173:
+		goto tr160
+	tr172:
 //line NONE:1
 		te = p + 1
 
@@ -2652,63 +2629,63 @@ func (l *lexer) next() token {
 			goto _test_eof114
 		}
 	st_case_114:
-//line lexer.go:2174
+//line lexer.go:2159
 		switch data[p] {
 		case 46:
-			goto tr162
+			goto tr161
 		case 68:
-			goto tr107
+			goto tr105
 		case 69:
-			goto st83
+			goto st82
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr107
+			goto tr105
 		case 101:
-			goto st83
+			goto st82
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr176
+				goto tr175
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st81
+				goto st80
 			}
 		default:
-			goto st81
+			goto st80
 		}
-		goto tr161
-	tr176:
+		goto tr160
+	tr175:
 //line NONE:1
 		te = p + 1
 
@@ -2720,63 +2697,63 @@ func (l *lexer) next() token {
 			goto _test_eof115
 		}
 	st_case_115:
-//line lexer.go:2242
+//line lexer.go:2227
 		switch data[p] {
 		case 46:
-			goto tr162
+			goto tr161
 		case 68:
-			goto tr103
+			goto tr101
 		case 69:
-			goto st80
+			goto st79
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr103
+			goto tr101
 		case 101:
-			goto st80
+			goto st79
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr178
+				goto tr177
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st78
+				goto st77
 			}
 		default:
-			goto st78
+			goto st77
 		}
-		goto tr161
-	tr178:
+		goto tr160
+	tr177:
 //line NONE:1
 		te = p + 1
 
@@ -2788,63 +2765,63 @@ func (l *lexer) next() token {
 			goto _test_eof116
 		}
 	st_case_116:
-//line lexer.go:2310
+//line lexer.go:2295
 		switch data[p] {
 		case 46:
-			goto tr162
+			goto tr161
 		case 68:
-			goto tr99
+			goto tr97
 		case 69:
-			goto st77
+			goto st76
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr99
+			goto tr97
 		case 101:
-			goto st77
+			goto st76
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr180
+				goto tr179
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st75
+				goto st74
 			}
 		default:
-			goto st75
+			goto st74
 		}
-		goto tr161
-	tr180:
+		goto tr160
+	tr179:
 //line NONE:1
 		te = p + 1
 
@@ -2856,63 +2833,63 @@ func (l *lexer) next() token {
 			goto _test_eof117
 		}
 	st_case_117:
-//line lexer.go:2378
+//line lexer.go:2363
 		switch data[p] {
 		case 46:
-			goto tr162
+			goto tr161
 		case 68:
-			goto tr95
+			goto tr93
 		case 69:
-			goto st74
+			goto st73
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr95
+			goto tr93
 		case 101:
-			goto st74
+			goto st73
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr182
+				goto tr181
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st72
+				goto st71
 			}
 		default:
-			goto st72
+			goto st71
 		}
-		goto tr161
-	tr182:
+		goto tr160
+	tr181:
 //line NONE:1
 		te = p + 1
 
@@ -2924,63 +2901,63 @@ func (l *lexer) next() token {
 			goto _test_eof118
 		}
 	st_case_118:
-//line lexer.go:2446
+//line lexer.go:2431
 		switch data[p] {
 		case 46:
-			goto tr162
+			goto tr161
 		case 68:
-			goto tr91
+			goto tr89
 		case 69:
-			goto st70
+			goto st69
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr91
+			goto tr89
 		case 101:
-			goto st70
+			goto st69
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr184
+				goto tr183
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st69
+				goto st68
 			}
 		default:
-			goto st69
+			goto st68
 		}
-		goto tr161
-	tr184:
+		goto tr160
+	tr183:
 //line NONE:1
 		te = p + 1
 
@@ -2992,55 +2969,73 @@ func (l *lexer) next() token {
 			goto _test_eof119
 		}
 	st_case_119:
-//line lexer.go:2514
+//line lexer.go:2499
 		switch data[p] {
 		case 45:
-			goto st42
+			goto st41
 		case 46:
-			goto tr162
+			goto tr161
 		case 68:
-			goto tr13
+			goto tr11
 		case 69:
-			goto st4
+			goto st3
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr13
+			goto tr11
 		case 101:
-			goto st4
+			goto st3
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto tr156
+			goto tr155
+		}
+		goto tr160
+	st41:
+		if p++; p == pe {
+			goto _test_eof41
+		}
+	st_case_41:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st42
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st42
+			}
+		default:
+			goto st42
 		}
-		goto tr161
+		goto tr0
 	st42:
 		if p++; p == pe {
 			goto _test_eof42
@@ -3100,16 +3095,7 @@ func (l *lexer) next() token {
 			goto _test_eof45
 		}
 	st_case_45:
-		switch {
-		case data[p] < 65:
-			if 48 <= data[p] && data[p] <= 57 {
-				goto st46
-			}
-		case data[p] > 70:
-			if 97 <= data[p] && data[p] <= 102 {
-				goto st46
-			}
-		default:
+		if data[p] == 45 {
 			goto st46
 		}
 		goto tr0
@@ -3118,7 +3104,16 @@ func (l *lexer) next() token {
 			goto _test_eof46
 		}
 	st_case_46:
-		if data[p] == 45 {
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st47
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st47
+			}
+		default:
 			goto st47
 		}
 		goto tr0
@@ -3181,16 +3176,7 @@ func (l *lexer) next() token {
 			goto _test_eof50
 		}
 	st_case_50:
-		switch {
-		case data[p] < 65:
-			if 48 <= data[p] && data[p] <= 57 {
-				goto st51
-			}
-		case data[p] > 70:
-			if 97 <= data[p] && data[p] <= 102 {
-				goto st51
-			}
-		default:
+		if data[p] == 45 {
 			goto st51
 		}
 		goto tr0
@@ -3199,7 +3185,16 @@ func (l *lexer) next() token {
 			goto _test_eof51
 		}
 	st_case_51:
-		if data[p] == 45 {
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st52
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st52
+			}
+		default:
 			goto st52
 		}
 		goto tr0
@@ -3262,16 +3257,7 @@ func (l *lexer) next() token {
 			goto _test_eof55
 		}
 	st_case_55:
-		switch {
-		case data[p] < 65:
-			if 48 <= data[p] && data[p] <= 57 {
-				goto st56
-			}
-		case data[p] > 70:
-			if 97 <= data[p] && data[p] <= 102 {
-				goto st56
-			}
-		default:
+		if data[p] == 45 {
 			goto st56
 		}
 		goto tr0
@@ -3280,7 +3266,16 @@ func (l *lexer) next() token {
 			goto _test_eof56
 		}
 	st_case_56:
-		if data[p] == 45 {
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st57
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st57
+			}
+		default:
 			goto st57
 		}
 		goto tr0
@@ -3472,14 +3467,14 @@ func (l *lexer) next() token {
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st68
+				goto tr80
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st68
+				goto tr80
 			}
 		default:
-			goto st68
+			goto tr80
 		}
 		goto tr0
 	st68:
@@ -3487,29 +3482,11 @@ func (l *lexer) next() token {
 			goto _test_eof68
 		}
 	st_case_68:
-		switch {
-		case data[p] < 65:
-			if 48 <= data[p] && data[p] <= 57 {
-				goto tr82
-			}
-		case data[p] > 70:
-			if 97 <= data[p] && data[p] <= 102 {
-				goto tr82
-			}
-		default:
-			goto tr82
-		}
-		goto tr0
-	st69:
-		if p++; p == pe {
-			goto _test_eof69
-		}
-	st_case_69:
 		if data[p] == 45 {
-			goto st42
+			goto st41
 		}
 		goto tr0
-	tr91:
+	tr89:
 //line NONE:1
 		te = p + 1
 
@@ -3521,48 +3498,48 @@ func (l *lexer) next() token {
 			goto _test_eof120
 		}
 	st_case_120:
-//line lexer.go:3043
+//line lexer.go:3028
 		if data[p] == 45 {
-			goto st42
+			goto st41
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st6
+			goto st5
 		}
-		goto tr165
-	st70:
+		goto tr164
+	st69:
 		if p++; p == pe {
-			goto _test_eof70
+			goto _test_eof69
 		}
-	st_case_70:
+	st_case_69:
 		switch data[p] {
 		case 43:
-			goto st5
+			goto st4
 		case 45:
-			goto st71
+			goto st70
 		}
 		if 48 <= data[p] && data[p] <= 57 {
 			goto st102
 		}
-		goto tr84
-	st71:
+		goto tr82
+	st70:
 		if p++; p == pe {
-			goto _test_eof71
+			goto _test_eof70
 		}
-	st_case_71:
+	st_case_70:
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr86
+				goto tr84
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st43
+				goto st42
 			}
 		default:
-			goto st43
+			goto st42
 		}
-		goto tr84
-	tr86:
+		goto tr82
+	tr84:
 //line NONE:1
 		te = p + 1
 
@@ -3574,21 +3551,21 @@ func (l *lexer) next() token {
 			goto _test_eof121
 		}
 	st_case_121:
-//line lexer.go:3096
+//line lexer.go:3081
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr186
+				goto tr185
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st44
+				goto st43
 			}
 		default:
-			goto st44
+			goto st43
 		}
-		goto tr164
-	tr186:
+		goto tr163
+	tr185:
 //line NONE:1
 		te = p + 1
 
@@ -3600,21 +3577,21 @@ func (l *lexer) next() token {
 			goto _test_eof122
 		}
 	st_case_122:
-//line lexer.go:3122
+//line lexer.go:3107
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr187
+				goto tr186
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st45
+				goto st44
 			}
 		default:
-			goto st45
+			goto st44
 		}
-		goto tr164
-	tr187:
+		goto tr163
+	tr186:
 //line NONE:1
 		te = p + 1
 
@@ -3626,21 +3603,21 @@ func (l *lexer) next() token {
 			goto _test_eof123
 		}
 	st_case_123:
-//line lexer.go:3148
+//line lexer.go:3133
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr188
+				goto tr187
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st46
+				goto st45
 			}
 		default:
-			goto st46
+			goto st45
 		}
-		goto tr164
-	tr188:
+		goto tr163
+	tr187:
 //line NONE:1
 		te = p + 1
 
@@ -3652,33 +3629,33 @@ func (l *lexer) next() token {
 			goto _test_eof124
 		}
 	st_case_124:
-//line lexer.go:3174
+//line lexer.go:3159
 		if data[p] == 45 {
-			goto st47
+			goto st46
 		}
 		if 48 <= data[p] && data[p] <= 57 {
 			goto st102
 		}
-		goto tr164
-	st72:
+		goto tr163
+	st71:
 		if p++; p == pe {
-			goto _test_eof72
+			goto _test_eof71
 		}
-	st_case_72:
+	st_case_71:
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st69
+				goto st68
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st69
+				goto st68
 			}
 		default:
-			goto st69
+			goto st68
 		}
 		goto tr0
-	tr95:
+	tr93:
 //line NONE:1
 		te = p + 1
 
@@ -3690,92 +3667,92 @@ func (l *lexer) next() token {
 			goto _test_eof125
 		}
 	st_case_125:
-//line lexer.go:3212
+//line lexer.go:3197
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st73
+				goto st72
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st69
+				goto st68
 			}
 		default:
-			goto st69
+			goto st68
 		}
-		goto tr165
-	st73:
+		goto tr164
+	st72:
 		if p++; p == pe {
-			goto _test_eof73
+			goto _test_eof72
 		}
-	st_case_73:
+	st_case_72:
 		switch data[p] {
 		case 45:
-			goto st42
+			goto st41
 		case 68:
-			goto tr13
+			goto tr11
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr13
+			goto tr11
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		if 48 <= data[p] && data[p] <= 57 {
-			goto st6
+			goto st5
 		}
-		goto tr11
-	st74:
+		goto tr9
+	st73:
 		if p++; p == pe {
-			goto _test_eof74
+			goto _test_eof73
 		}
-	st_case_74:
+	st_case_73:
 		switch data[p] {
 		case 43:
-			goto st5
+			goto st4
 		case 45:
-			goto st5
+			goto st4
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr88
+				goto tr86
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st69
+				goto st68
 			}
 		default:
-			goto st69
+			goto st68
 		}
-		goto tr84
-	tr88:
+		goto tr82
+	tr86:
 //line NONE:1
 		te = p + 1
 
@@ -3787,33 +3764,33 @@ func (l *lexer) next() token {
 			goto _test_eof126
 		}
 	st_case_126:
-//line lexer.go:3309
+//line lexer.go:3294
 		if data[p] == 45 {
-			goto st42
+			goto st41
 		}
 		if 48 <= data[p] && data[p] <= 57 {
 			goto st102
 		}
-		goto tr164
-	st75:
+		goto tr163
+	st74:
 		if p++; p == pe {
-			goto _test_eof75
+			goto _test_eof74
 		}
-	st_case_75:
+	st_case_74:
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st72
+				goto st71
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st72
+				goto st71
 			}
 		default:
-			goto st72
+			goto st71
 		}
 		goto tr0
-	tr99:
+	tr97:
 //line NONE:1
 		te = p + 1
 
@@ -3825,99 +3802,99 @@ func (l *lexer) next() token {
 			goto _test_eof127
 		}
 	st_case_127:
-//line lexer.go:3347
+//line lexer.go:3332
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st76
+				goto st75
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st72
+				goto st71
 			}
 		default:
-			goto st72
+			goto st71
 		}
-		goto tr165
-	st76:
+		goto tr164
+	st75:
 		if p++; p == pe {
-			goto _test_eof76
+			goto _test_eof75
 		}
-	st_case_76:
+	st_case_75:
 		switch data[p] {
 		case 68:
-			goto tr91
+			goto tr89
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr91
+			goto tr89
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st73
+				goto st72
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st69
+				goto st68
 			}
 		default:
-			goto st69
+			goto st68
 		}
-		goto tr11
-	st77:
+		goto tr9
+	st76:
 		if p++; p == pe {
-			goto _test_eof77
+			goto _test_eof76
 		}
-	st_case_77:
+	st_case_76:
 		switch data[p] {
 		case 43:
-			goto st5
+			goto st4
 		case 45:
-			goto st5
+			goto st4
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr92
+				goto tr90
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st72
+				goto st71
 			}
 		default:
-			goto st72
+			goto st71
 		}
-		goto tr84
-	tr92:
+		goto tr82
+	tr90:
 //line NONE:1
 		te = p + 1
 
@@ -3929,39 +3906,39 @@ func (l *lexer) next() token {
 			goto _test_eof128
 		}
 	st_case_128:
-//line lexer.go:3451
+//line lexer.go:3436
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr88
+				goto tr86
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st69
+				goto st68
 			}
 		default:
-			goto st69
+			goto st68
 		}
-		goto tr164
-	st78:
+		goto tr163
+	st77:
 		if p++; p == pe {
-			goto _test_eof78
+			goto _test_eof77
 		}
-	st_case_78:
+	st_case_77:
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st75
+				goto st74
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st75
+				goto st74
 			}
 		default:
-			goto st75
+			goto st74
 		}
 		goto tr0
-	tr103:
+	tr101:
 //line NONE:1
 		te = p + 1
 
@@ -3973,99 +3950,99 @@ func (l *lexer) next() token {
 			goto _test_eof129
 		}
 	st_case_129:
-//line lexer.go:3495
+//line lexer.go:3480
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st79
+				goto st78
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st75
+				goto st74
 			}
 		default:
-			goto st75
+			goto st74
 		}
-		goto tr165
-	st79:
+		goto tr164
+	st78:
 		if p++; p == pe {
-			goto _test_eof79
+			goto _test_eof78
 		}
-	st_case_79:
+	st_case_78:
 		switch data[p] {
 		case 68:
-			goto tr95
+			goto tr93
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr95
+			goto tr93
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st76
+				goto st75
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st72
+				goto st71
 			}
 		default:
-			goto st72
+			goto st71
 		}
-		goto tr11
-	st80:
+		goto tr9
+	st79:
 		if p++; p == pe {
-			goto _test_eof80
+			goto _test_eof79
 		}
-	st_case_80:
+	st_case_79:
 		switch data[p] {
 		case 43:
-			goto st5
+			goto st4
 		case 45:
-			goto st5
+			goto st4
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr96
+				goto tr94
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st75
+				goto st74
 			}
 		default:
-			goto st75
+			goto st74
 		}
-		goto tr84
-	tr96:
+		goto tr82
+	tr94:
 //line NONE:1
 		te = p + 1
 
@@ -4077,39 +4054,39 @@ func (l *lexer) next() token {
 			goto _test_eof130
 		}
 	st_case_130:
-//line lexer.go:3599
+//line lexer.go:3584
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr92
+				goto tr90
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st72
+				goto st71
 			}
 		default:
-			goto st72
+			goto st71
 		}
-		goto tr164
-	st81:
+		goto tr163
+	st80:
 		if p++; p == pe {
-			goto _test_eof81
+			goto _test_eof80
 		}
-	st_case_81:
+	st_case_80:
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st78
+				goto st77
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st78
+				goto st77
 			}
 		default:
-			goto st78
+			goto st77
 		}
 		goto tr0
-	tr107:
+	tr105:
 //line NONE:1
 		te = p + 1
 
@@ -4121,99 +4098,99 @@ func (l *lexer) next() token {
 			goto _test_eof131
 		}
 	st_case_131:
-//line lexer.go:3643
+//line lexer.go:3628
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st82
+				goto st81
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st78
+				goto st77
 			}
 		default:
-			goto st78
+			goto st77
 		}
-		goto tr165
-	st82:
+		goto tr164
+	st81:
 		if p++; p == pe {
-			goto _test_eof82
+			goto _test_eof81
 		}
-	st_case_82:
+	st_case_81:
 		switch data[p] {
 		case 68:
-			goto tr99
+			goto tr97
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr99
+			goto tr97
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st79
+				goto st78
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st75
+				goto st74
 			}
 		default:
-			goto st75
+			goto st74
 		}
-		goto tr11
-	st83:
+		goto tr9
+	st82:
 		if p++; p == pe {
-			goto _test_eof83
+			goto _test_eof82
 		}
-	st_case_83:
+	st_case_82:
 		switch data[p] {
 		case 43:
-			goto st5
+			goto st4
 		case 45:
-			goto st5
+			goto st4
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr100
+				goto tr98
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st78
+				goto st77
 			}
 		default:
-			goto st78
+			goto st77
 		}
-		goto tr84
-	tr100:
+		goto tr82
+	tr98:
 //line NONE:1
 		te = p + 1
 
@@ -4225,39 +4202,39 @@ func (l *lexer) next() token {
 			goto _test_eof132
 		}
 	st_case_132:
-//line lexer.go:3747
+//line lexer.go:3732
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr96
+				goto tr94
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st75
+				goto st74
 			}
 		default:
-			goto st75
+			goto st74
 		}
-		goto tr164
-	st84:
+		goto tr163
+	st83:
 		if p++; p == pe {
-			goto _test_eof84
+			goto _test_eof83
 		}
-	st_case_84:
+	st_case_83:
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st81
+				goto st80
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st81
+				goto st80
 			}
 		default:
-			goto st81
+			goto st80
 		}
 		goto tr0
-	tr174:
+	tr173:
 //line NONE:1
 		te = p + 1
 
@@ -4269,99 +4246,99 @@ func (l *lexer) next() token {
 			goto _test_eof133
 		}
 	st_case_133:
-//line lexer.go:3791
+//line lexer.go:3776
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st85
+				goto st84
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st81
+				goto st80
 			}
 		default:
-			goto st81
+			goto st80
 		}
-		goto tr165
-	st85:
+		goto tr164
+	st84:
 		if p++; p == pe {
-			goto _test_eof85
+			goto _test_eof84
 		}
-	st_case_85:
+	st_case_84:
 		switch data[p] {
 		case 68:
-			goto tr103
+			goto tr101
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr103
+			goto tr101
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st82
+				goto st81
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st78
+				goto st77
 			}
 		default:
-			goto st78
+			goto st77
 		}
-		goto tr11
-	st86:
+		goto tr9
+	st85:
 		if p++; p == pe {
-			goto _test_eof86
+			goto _test_eof85
 		}
-	st_case_86:
+	st_case_85:
 		switch data[p] {
 		case 43:
-			goto st5
+			goto st4
 		case 45:
-			goto st5
+			goto st4
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr104
+				goto tr102
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st81
+				goto st80
 			}
 		default:
-			goto st81
+			goto st80
 		}
-		goto tr84
-	tr104:
+		goto tr82
+	tr102:
 //line NONE:1
 		te = p + 1
 
@@ -4373,39 +4350,39 @@ func (l *lexer) next() token {
 			goto _test_eof134
 		}
 	st_case_134:
-//line lexer.go:3895
+//line lexer.go:3880
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr100
+				goto tr98
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st78
+				goto st77
 			}
 		default:
-			goto st78
+			goto st77
 		}
-		goto tr164
-	st87:
+		goto tr163
+	st86:
 		if p++; p == pe {
-			goto _test_eof87
+			goto _test_eof86
 		}
-	st_case_87:
+	st_case_86:
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st84
+				goto st83
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st84
+				goto st83
 			}
 		default:
-			goto st84
+			goto st83
 		}
-		goto tr84
-	tr170:
+		goto tr82
+	tr169:
 //line NONE:1
 		te = p + 1
 
@@ -4417,99 +4394,99 @@ func (l *lexer) next() token {
 			goto _test_eof135
 		}
 	st_case_135:
-//line lexer.go:3939
+//line lexer.go:3924
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st88
+				goto st87
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st84
+				goto st83
 			}
 		default:
-			goto st84
+			goto st83
 		}
-		goto tr165
-	st88:
+		goto tr164
+	st87:
 		if p++; p == pe {
-			goto _test_eof88
+			goto _test_eof87
 		}
-	st_case_88:
+	st_case_87:
 		switch data[p] {
 		case 68:
-			goto tr107
+			goto tr105
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr107
+			goto tr105
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto st85
+				goto st84
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st81
+				goto st80
 			}
 		default:
-			goto st81
+			goto st80
 		}
-		goto tr11
-	st89:
+		goto tr9
+	st88:
 		if p++; p == pe {
-			goto _test_eof89
+			goto _test_eof88
 		}
-	st_case_89:
+	st_case_88:
 		switch data[p] {
 		case 43:
-			goto st5
+			goto st4
 		case 45:
-			goto st5
+			goto st4
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr108
+				goto tr106
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st84
+				goto st83
 			}
 		default:
-			goto st84
+			goto st83
 		}
-		goto tr84
-	tr108:
+		goto tr82
+	tr106:
 //line NONE:1
 		te = p + 1
 
@@ -4521,20 +4498,20 @@ func (l *lexer) next() token {
 			goto _test_eof136
 		}
 	st_case_136:
-//line lexer.go:4043
+//line lexer.go:4028
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr104
+				goto tr102
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st81
+				goto st80
 			}
 		default:
-			goto st81
+			goto st80
 		}
-		goto tr164
+		goto tr163
 	st137:
 		if p++; p == pe {
 			goto _test_eof137
@@ -4552,8 +4529,8 @@ func (l *lexer) next() token {
 		default:
 			goto st137
 		}
-		goto tr190
-	tr125:
+		goto tr189
+	tr123:
 //line NONE:1
 		te = p + 1
 
@@ -4565,80 +4542,80 @@ func (l *lexer) next() token {
 			goto _test_eof138
 		}
 	st_case_138:
-//line lexer.go:4087
+//line lexer.go:4072
 		switch data[p] {
 		case 46:
-			goto tr162
+			goto tr161
 		case 68:
-			goto tr170
+			goto tr169
 		case 69:
-			goto st89
+			goto st88
 		case 72:
-			goto tr13
+			goto tr11
 		case 77:
-			goto tr14
+			goto tr12
 		case 78:
-			goto st7
+			goto st6
 		case 83:
-			goto tr13
+			goto tr11
 		case 85:
-			goto st7
+			goto st6
 		case 87:
-			goto tr13
+			goto tr11
 		case 89:
-			goto tr13
+			goto tr11
 		case 100:
-			goto tr170
+			goto tr169
 		case 101:
-			goto st89
+			goto st88
 		case 104:
-			goto tr13
+			goto tr11
 		case 109:
-			goto tr14
+			goto tr12
 		case 110:
-			goto st7
+			goto st6
 		case 115:
-			goto tr13
+			goto tr11
 		case 117:
-			goto st7
+			goto st6
 		case 119:
-			goto tr13
+			goto tr11
 		case 121:
-			goto tr13
+			goto tr11
 		case 194:
-			goto st8
+			goto st7
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr168
+				goto tr167
 			}
 		case data[p] > 70:
 			if 97 <= data[p] && data[p] <= 102 {
-				goto st87
+				goto st86
 			}
 		default:
-			goto st87
+			goto st86
 		}
-		goto tr161
+		goto tr160
 	st139:
 		if p++; p == pe {
 			goto _test_eof139
 		}
 	st_case_139:
 		if data[p] == 61 {
-			goto tr192
+			goto tr191
 		}
-		goto tr191
+		goto tr190
 	st140:
 		if p++; p == pe {
 			goto _test_eof140
 		}
 	st_case_140:
 		if data[p] == 61 {
-			goto tr194
+			goto tr193
 		}
-		goto tr193
+		goto tr192
 	st141:
 		if p++; p == pe {
 			goto _test_eof141
@@ -4652,7 +4629,7 @@ func (l *lexer) next() token {
 		case 80:
 			goto st154
 		case 95:
-			goto tr138
+			goto tr136
 		case 108:
 			goto st150
 		case 110:
@@ -4674,22 +4651,22 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st142
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st142:
 		if p++; p == pe {
 			goto _test_eof142
 		}
 	st_case_142:
 		if data[p] == 95 {
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 71:
@@ -4705,22 +4682,22 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st143
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st143:
 		if p++; p == pe {
 			goto _test_eof143
 		}
 	st_case_143:
 		if data[p] == 95 {
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 71:
@@ -4736,22 +4713,22 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st144
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st144:
 		if p++; p == pe {
 			goto _test_eof144
 		}
 	st_case_144:
 		if data[p] == 95 {
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 71:
@@ -4767,22 +4744,22 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st145
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st145:
 		if p++; p == pe {
 			goto _test_eof145
 		}
 	st_case_145:
 		if data[p] == 95 {
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 71:
@@ -4798,22 +4775,22 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st146
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st146:
 		if p++; p == pe {
 			goto _test_eof146
 		}
 	st_case_146:
 		if data[p] == 95 {
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 71:
@@ -4829,47 +4806,47 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st147
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st147:
 		if p++; p == pe {
 			goto _test_eof147
 		}
 	st_case_147:
 		if data[p] == 95 {
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 71:
 			switch {
 			case data[p] > 57:
 				if 65 <= data[p] && data[p] <= 70 {
-					goto tr205
+					goto tr203
 				}
 			case data[p] >= 48:
-				goto tr205
+				goto tr203
 			}
 		case data[p] > 90:
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
-				goto tr205
+				goto tr203
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
-	tr205:
+		goto tr150
+	tr203:
 //line NONE:1
 		te = p + 1
 
@@ -4881,202 +4858,202 @@ func (l *lexer) next() token {
 			goto _test_eof148
 		}
 	st_case_148:
-//line lexer.go:4403
+//line lexer.go:4388
 		switch data[p] {
 		case 45:
-			goto st42
+			goto st41
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
-	tr138:
+		goto tr150
+	tr136:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:204
 		act = 54
 		goto st149
-	tr269:
+	tr267:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:202
 		act = 52
 		goto st149
-	tr208:
+	tr206:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:159
 		act = 9
 		goto st149
-	tr209:
+	tr207:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:167
 		act = 17
 		goto st149
-	tr212:
+	tr210:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:157
 		act = 7
 		goto st149
-	tr217:
+	tr215:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:155
 		act = 5
 		goto st149
-	tr220:
+	tr218:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:156
 		act = 6
 		goto st149
-	tr225:
+	tr223:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:158
 		act = 8
 		goto st149
-	tr231:
+	tr229:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:154
 		act = 4
 		goto st149
-	tr233:
+	tr231:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:160
 		act = 10
 		goto st149
-	tr238:
+	tr236:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:172
 		act = 22
 		goto st149
-	tr240:
+	tr238:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:162
 		act = 12
 		goto st149
-	tr241:
+	tr239:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:165
 		act = 15
 		goto st149
-	tr243:
+	tr241:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:168
 		act = 18
 		goto st149
-	tr252:
+	tr250:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:196
 		act = 46
 		goto st149
-	tr255:
+	tr253:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:152
 		act = 2
 		goto st149
-	tr256:
+	tr254:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:161
 		act = 11
 		goto st149
-	tr260:
+	tr258:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:195
 		act = 45
 		goto st149
-	tr261:
+	tr259:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:170
 		act = 20
 		goto st149
-	tr263:
+	tr261:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:173
 		act = 23
 		goto st149
-	tr285:
+	tr283:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:151
 		act = 1
 		goto st149
-	tr290:
+	tr288:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:171
 		act = 21
 		goto st149
-	tr296:
+	tr294:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:153
 		act = 3
 		goto st149
-	tr297:
+	tr295:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:163
 		act = 13
 		goto st149
-	tr300:
+	tr298:
 //line NONE:1
 		te = p + 1
 
 //line lexer.rl:164
 		act = 14
 		goto st149
-	tr304:
+	tr302:
 //line NONE:1
 		te = p + 1
 
@@ -5088,21 +5065,21 @@ func (l *lexer) next() token {
 			goto _test_eof149
 		}
 	st_case_149:
-//line lexer.go:4610
+//line lexer.go:4595
 		if data[p] == 95 {
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
 		goto tr0
 	st150:
@@ -5114,23 +5091,23 @@ func (l *lexer) next() token {
 		case 84:
 			goto st151
 		case 95:
-			goto tr138
+			goto tr136
 		case 116:
 			goto st151
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st151:
 		if p++; p == pe {
 			goto _test_eof151
@@ -5140,23 +5117,23 @@ func (l *lexer) next() token {
 		case 69:
 			goto st152
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
 			goto st152
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st152:
 		if p++; p == pe {
 			goto _test_eof152
@@ -5164,25 +5141,25 @@ func (l *lexer) next() token {
 	st_case_152:
 		switch data[p] {
 		case 82:
-			goto tr208
+			goto tr206
 		case 95:
-			goto tr138
+			goto tr136
 		case 114:
-			goto tr208
+			goto tr206
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st153:
 		if p++; p == pe {
 			goto _test_eof153
@@ -5190,25 +5167,25 @@ func (l *lexer) next() token {
 	st_case_153:
 		switch data[p] {
 		case 68:
-			goto tr209
+			goto tr207
 		case 95:
-			goto tr138
+			goto tr136
 		case 100:
-			goto tr209
+			goto tr207
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st154:
 		if p++; p == pe {
 			goto _test_eof154
@@ -5218,23 +5195,23 @@ func (l *lexer) next() token {
 		case 80:
 			goto st155
 		case 95:
-			goto tr138
+			goto tr136
 		case 112:
 			goto st155
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st155:
 		if p++; p == pe {
 			goto _test_eof155
@@ -5244,23 +5221,23 @@ func (l *lexer) next() token {
 		case 76:
 			goto st156
 		case 95:
-			goto tr138
+			goto tr136
 		case 108:
 			goto st156
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st156:
 		if p++; p == pe {
 			goto _test_eof156
@@ -5268,25 +5245,25 @@ func (l *lexer) next() token {
 	st_case_156:
 		switch data[p] {
 		case 89:
-			goto tr212
+			goto tr210
 		case 95:
-			goto tr138
+			goto tr136
 		case 121:
-			goto tr212
+			goto tr210
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st157:
 		if p++; p == pe {
 			goto _test_eof157
@@ -5298,7 +5275,7 @@ func (l *lexer) next() token {
 		case 69:
 			goto st161
 		case 95:
-			goto tr138
+			goto tr136
 		case 97:
 			goto st158
 		case 101:
@@ -5318,15 +5295,15 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 98:
 				goto st142
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st158:
 		if p++; p == pe {
 			goto _test_eof158
@@ -5336,7 +5313,7 @@ func (l *lexer) next() token {
 		case 84:
 			goto st159
 		case 95:
-			goto tr138
+			goto tr136
 		case 116:
 			goto st159
 		}
@@ -5354,15 +5331,15 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st143
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st159:
 		if p++; p == pe {
 			goto _test_eof159
@@ -5372,23 +5349,23 @@ func (l *lexer) next() token {
 		case 67:
 			goto st160
 		case 95:
-			goto tr138
+			goto tr136
 		case 99:
 			goto st160
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st160:
 		if p++; p == pe {
 			goto _test_eof160
@@ -5396,25 +5373,25 @@ func (l *lexer) next() token {
 	st_case_160:
 		switch data[p] {
 		case 72:
-			goto tr217
+			goto tr215
 		case 95:
-			goto tr138
+			goto tr136
 		case 104:
-			goto tr217
+			goto tr215
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st161:
 		if p++; p == pe {
 			goto _test_eof161
@@ -5424,7 +5401,7 @@ func (l *lexer) next() token {
 		case 71:
 			goto st162
 		case 95:
-			goto tr138
+			goto tr136
 		case 103:
 			goto st162
 		}
@@ -5442,15 +5419,15 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 104 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st143
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st162:
 		if p++; p == pe {
 			goto _test_eof162
@@ -5460,23 +5437,23 @@ func (l *lexer) next() token {
 		case 73:
 			goto st163
 		case 95:
-			goto tr138
+			goto tr136
 		case 105:
 			goto st163
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st163:
 		if p++; p == pe {
 			goto _test_eof163
@@ -5484,25 +5461,25 @@ func (l *lexer) next() token {
 	st_case_163:
 		switch data[p] {
 		case 78:
-			goto tr220
+			goto tr218
 		case 95:
-			goto tr138
+			goto tr136
 		case 110:
-			goto tr220
+			goto tr218
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st164:
 		if p++; p == pe {
 			goto _test_eof164
@@ -5512,7 +5489,7 @@ func (l *lexer) next() token {
 		case 82:
 			goto st165
 		case 95:
-			goto tr138
+			goto tr136
 		case 114:
 			goto st165
 		}
@@ -5530,15 +5507,15 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st142
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st165:
 		if p++; p == pe {
 			goto _test_eof165
@@ -5548,23 +5525,23 @@ func (l *lexer) next() token {
 		case 69:
 			goto st166
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
 			goto st166
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st166:
 		if p++; p == pe {
 			goto _test_eof166
@@ -5574,23 +5551,23 @@ func (l *lexer) next() token {
 		case 65:
 			goto st167
 		case 95:
-			goto tr138
+			goto tr136
 		case 97:
 			goto st167
 		}
 		switch {
 		case data[p] < 66:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 98 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st167:
 		if p++; p == pe {
 			goto _test_eof167
@@ -5600,23 +5577,23 @@ func (l *lexer) next() token {
 		case 84:
 			goto st168
 		case 95:
-			goto tr138
+			goto tr136
 		case 116:
 			goto st168
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st168:
 		if p++; p == pe {
 			goto _test_eof168
@@ -5624,25 +5601,25 @@ func (l *lexer) next() token {
 	st_case_168:
 		switch data[p] {
 		case 69:
-			goto tr225
+			goto tr223
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
-			goto tr225
+			goto tr223
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st169:
 		if p++; p == pe {
 			goto _test_eof169
@@ -5654,7 +5631,7 @@ func (l *lexer) next() token {
 		case 82:
 			goto st174
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
 			goto st170
 		case 114:
@@ -5674,15 +5651,15 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st142
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st170:
 		if p++; p == pe {
 			goto _test_eof170
@@ -5692,7 +5669,7 @@ func (l *lexer) next() token {
 		case 76:
 			goto st171
 		case 95:
-			goto tr138
+			goto tr136
 		case 108:
 			goto st171
 		}
@@ -5710,15 +5687,15 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st143
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st171:
 		if p++; p == pe {
 			goto _test_eof171
@@ -5728,23 +5705,23 @@ func (l *lexer) next() token {
 		case 69:
 			goto st172
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
 			goto st172
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st172:
 		if p++; p == pe {
 			goto _test_eof172
@@ -5754,23 +5731,23 @@ func (l *lexer) next() token {
 		case 84:
 			goto st173
 		case 95:
-			goto tr138
+			goto tr136
 		case 116:
 			goto st173
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st173:
 		if p++; p == pe {
 			goto _test_eof173
@@ -5778,25 +5755,25 @@ func (l *lexer) next() token {
 	st_case_173:
 		switch data[p] {
 		case 69:
-			goto tr231
+			goto tr229
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
-			goto tr231
+			goto tr229
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st174:
 		if p++; p == pe {
 			goto _test_eof174
@@ -5806,23 +5783,23 @@ func (l *lexer) next() token {
 		case 79:
 			goto st175
 		case 95:
-			goto tr138
+			goto tr136
 		case 111:
 			goto st175
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st175:
 		if p++; p == pe {
 			goto _test_eof175
@@ -5830,32 +5807,32 @@ func (l *lexer) next() token {
 	st_case_175:
 		switch data[p] {
 		case 80:
-			goto tr233
+			goto tr231
 		case 95:
-			goto tr138
+			goto tr136
 		case 112:
-			goto tr233
+			goto tr231
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st176:
 		if p++; p == pe {
 			goto _test_eof176
 		}
 	st_case_176:
 		if data[p] == 95 {
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 71:
@@ -5871,15 +5848,15 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st142
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st177:
 		if p++; p == pe {
 			goto _test_eof177
@@ -5891,7 +5868,7 @@ func (l *lexer) next() token {
 		case 82:
 			goto st181
 		case 95:
-			goto tr138
+			goto tr136
 		case 97:
 			goto st178
 		case 114:
@@ -5911,15 +5888,15 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 98:
 				goto st142
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st178:
 		if p++; p == pe {
 			goto _test_eof178
@@ -5929,7 +5906,7 @@ func (l *lexer) next() token {
 		case 76:
 			goto st179
 		case 95:
-			goto tr138
+			goto tr136
 		case 108:
 			goto st179
 		}
@@ -5947,15 +5924,15 @@ func (l *lexer) next() token {
 			switch {
 			case data[p] > 102:
 				if 103 <= data[p] && data[p] <= 122 {
-					goto tr138
+					goto tr136
 				}
 			case data[p] >= 97:
 				goto st143
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st179:
 		if p++; p == pe {
 			goto _test_eof179
@@ -5965,23 +5942,23 @@ func (l *lexer) next() token {
 		case 83:
 			goto st180
 		case 95:
-			goto tr138
+			goto tr136
 		case 115:
 			goto st180
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st180:
 		if p++; p == pe {
 			goto _test_eof180
@@ -5989,25 +5966,25 @@ func (l *lexer) next() token {
 	st_case_180:
 		switch data[p] {
 		case 69:
-			goto tr238
+			goto tr236
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
-			goto tr238
+			goto tr236
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st181:
 		if p++; p == pe {
 			goto _test_eof181
@@ -6017,23 +5994,23 @@ func (l *lexer) next() token {
 		case 79:
 			goto st182
 		case 95:
-			goto tr138
+			goto tr136
 		case 111:
 			goto st182
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st182:
 		if p++; p == pe {
 			goto _test_eof182
@@ -6041,25 +6018,25 @@ func (l *lexer) next() token {
 	st_case_182:
 		switch data[p] {
 		case 77:
-			goto tr240
+			goto tr238
 		case 95:
-			goto tr138
+			goto tr136
 		case 109:
-			goto tr240
+			goto tr238
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st183:
 		if p++; p == pe {
 			goto _test_eof183
@@ -6067,33 +6044,33 @@ func (l *lexer) next() token {
 	st_case_183:
 		switch data[p] {
 		case 70:
-			goto tr241
+			goto tr239
 		case 78:
 			goto st184
 		case 83:
-			goto tr243
+			goto tr241
 		case 95:
-			goto tr138
+			goto tr136
 		case 102:
-			goto tr241
+			goto tr239
 		case 110:
 			goto st184
 		case 115:
-			goto tr243
+			goto tr241
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st184:
 		if p++; p == pe {
 			goto _test_eof184
@@ -6107,7 +6084,7 @@ func (l *lexer) next() token {
 		case 84:
 			goto st193
 		case 95:
-			goto tr138
+			goto tr136
 		case 102:
 			goto st185
 		case 115:
@@ -6118,16 +6095,16 @@ func (l *lexer) next() token {
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr244
+		goto tr242
 	st185:
 		if p++; p == pe {
 			goto _test_eof185
@@ -6137,23 +6114,23 @@ func (l *lexer) next() token {
 		case 73:
 			goto st186
 		case 95:
-			goto tr138
+			goto tr136
 		case 105:
 			goto st186
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st186:
 		if p++; p == pe {
 			goto _test_eof186
@@ -6163,23 +6140,23 @@ func (l *lexer) next() token {
 		case 78:
 			goto st187
 		case 95:
-			goto tr138
+			goto tr136
 		case 110:
 			goto st187
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st187:
 		if p++; p == pe {
 			goto _test_eof187
@@ -6189,23 +6166,23 @@ func (l *lexer) next() token {
 		case 73:
 			goto st188
 		case 95:
-			goto tr138
+			goto tr136
 		case 105:
 			goto st188
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st188:
 		if p++; p == pe {
 			goto _test_eof188
@@ -6215,23 +6192,23 @@ func (l *lexer) next() token {
 		case 84:
 			goto st189
 		case 95:
-			goto tr138
+			goto tr136
 		case 116:
 			goto st189
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st189:
 		if p++; p == pe {
 			goto _test_eof189
@@ -6239,25 +6216,25 @@ func (l *lexer) next() token {
 	st_case_189:
 		switch data[p] {
 		case 89:
-			goto tr252
+			goto tr250
 		case 95:
-			goto tr138
+			goto tr136
 		case 121:
-			goto tr252
+			goto tr250
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st190:
 		if p++; p == pe {
 			goto _test_eof190
@@ -6267,23 +6244,23 @@ func (l *lexer) next() token {
 		case 69:
 			goto st191
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
 			goto st191
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st191:
 		if p++; p == pe {
 			goto _test_eof191
@@ -6293,23 +6270,23 @@ func (l *lexer) next() token {
 		case 82:
 			goto st192
 		case 95:
-			goto tr138
+			goto tr136
 		case 114:
 			goto st192
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st192:
 		if p++; p == pe {
 			goto _test_eof192
@@ -6317,25 +6294,25 @@ func (l *lexer) next() token {
 	st_case_192:
 		switch data[p] {
 		case 84:
-			goto tr255
+			goto tr253
 		case 95:
-			goto tr138
+			goto tr136
 		case 116:
-			goto tr255
+			goto tr253
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st193:
 		if p++; p == pe {
 			goto _test_eof193
@@ -6343,25 +6320,25 @@ func (l *lexer) next() token {
 	st_case_193:
 		switch data[p] {
 		case 79:
-			goto tr256
+			goto tr254
 		case 95:
-			goto tr138
+			goto tr136
 		case 111:
-			goto tr256
+			goto tr254
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st194:
 		if p++; p == pe {
 			goto _test_eof194
@@ -6375,7 +6352,7 @@ func (l *lexer) next() token {
 		case 85:
 			goto st197
 		case 95:
-			goto tr138
+			goto tr136
 		case 97:
 			goto st195
 		case 111:
@@ -6386,16 +6363,16 @@ func (l *lexer) next() token {
 		switch {
 		case data[p] < 66:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 98 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st195:
 		if p++; p == pe {
 			goto _test_eof195
@@ -6403,25 +6380,25 @@ func (l *lexer) next() token {
 	st_case_195:
 		switch data[p] {
 		case 78:
-			goto tr260
+			goto tr258
 		case 95:
-			goto tr138
+			goto tr136
 		case 110:
-			goto tr260
+			goto tr258
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st196:
 		if p++; p == pe {
 			goto _test_eof196
@@ -6429,25 +6406,25 @@ func (l *lexer) next() token {
 	st_case_196:
 		switch data[p] {
 		case 84:
-			goto tr261
+			goto tr259
 		case 95:
-			goto tr138
+			goto tr136
 		case 116:
-			goto tr261
+			goto tr259
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st197:
 		if p++; p == pe {
 			goto _test_eof197
@@ -6457,23 +6434,23 @@ func (l *lexer) next() token {
 		case 76:
 			goto st198
 		case 95:
-			goto tr138
+			goto tr136
 		case 108:
 			goto st198
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st198:
 		if p++; p == pe {
 			goto _test_eof198
@@ -6481,25 +6458,25 @@ func (l *lexer) next() token {
 	st_case_198:
 		switch data[p] {
 		case 76:
-			goto tr263
+			goto tr261
 		case 95:
-			goto tr138
+			goto tr136
 		case 108:
-			goto tr263
+			goto tr261
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st199:
 		if p++; p == pe {
 			goto _test_eof199
@@ -6509,7 +6486,7 @@ func (l *lexer) next() token {
 		case 84:
 			goto st206
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6518,12 +6495,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr165
+		goto tr164
 	st200:
 		if p++; p == pe {
 			goto _test_eof200
@@ -6535,11 +6512,11 @@ func (l *lexer) next() token {
 		case 77:
 			goto st212
 		case 87:
-			goto tr269
+			goto tr267
 		case 89:
 			goto st214
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6548,12 +6525,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st201:
 		if p++; p == pe {
 			goto _test_eof201
@@ -6565,11 +6542,11 @@ func (l *lexer) next() token {
 		case 77:
 			goto st212
 		case 87:
-			goto tr269
+			goto tr267
 		case 89:
 			goto st214
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6578,12 +6555,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st202:
 		if p++; p == pe {
 			goto _test_eof202
@@ -6595,26 +6572,26 @@ func (l *lexer) next() token {
 		case 77:
 			goto st212
 		case 87:
-			goto tr269
+			goto tr267
 		case 89:
 			goto st214
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr272
+				goto tr270
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
-	tr272:
+		goto tr150
+	tr270:
 //line NONE:1
 		te = p + 1
 
@@ -6626,20 +6603,20 @@ func (l *lexer) next() token {
 			goto _test_eof203
 		}
 	st_case_203:
-//line lexer.go:6148
+//line lexer.go:6133
 		switch data[p] {
 		case 45:
-			goto st22
+			goto st21
 		case 68:
 			goto st205
 		case 77:
 			goto st212
 		case 87:
-			goto tr269
+			goto tr267
 		case 89:
 			goto st214
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6648,12 +6625,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st204:
 		if p++; p == pe {
 			goto _test_eof204
@@ -6665,11 +6642,11 @@ func (l *lexer) next() token {
 		case 77:
 			goto st212
 		case 87:
-			goto tr269
+			goto tr267
 		case 89:
 			goto st214
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6678,12 +6655,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st205:
 		if p++; p == pe {
 			goto _test_eof205
@@ -6693,28 +6670,28 @@ func (l *lexer) next() token {
 		case 84:
 			goto st206
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr165
+		goto tr164
 	st206:
 		if p++; p == pe {
 			goto _test_eof206
 		}
 	st_case_206:
 		if data[p] == 95 {
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6723,12 +6700,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr165
+		goto tr164
 	st207:
 		if p++; p == pe {
 			goto _test_eof207
@@ -6740,9 +6717,9 @@ func (l *lexer) next() token {
 		case 77:
 			goto st210
 		case 83:
-			goto tr269
+			goto tr267
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6751,19 +6728,19 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st208:
 		if p++; p == pe {
 			goto _test_eof208
 		}
 	st_case_208:
 		if data[p] == 95 {
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6772,12 +6749,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr165
+		goto tr164
 	st209:
 		if p++; p == pe {
 			goto _test_eof209
@@ -6787,9 +6764,9 @@ func (l *lexer) next() token {
 		case 77:
 			goto st210
 		case 83:
-			goto tr269
+			goto tr267
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6798,19 +6775,19 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st210:
 		if p++; p == pe {
 			goto _test_eof210
 		}
 	st_case_210:
 		if data[p] == 95 {
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6819,12 +6796,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr165
+		goto tr164
 	st211:
 		if p++; p == pe {
 			goto _test_eof211
@@ -6832,9 +6809,9 @@ func (l *lexer) next() token {
 	st_case_211:
 		switch data[p] {
 		case 83:
-			goto tr269
+			goto tr267
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6843,12 +6820,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st212:
 		if p++; p == pe {
 			goto _test_eof212
@@ -6858,7 +6835,7 @@ func (l *lexer) next() token {
 		case 84:
 			goto st206
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6867,12 +6844,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr165
+		goto tr164
 	st213:
 		if p++; p == pe {
 			goto _test_eof213
@@ -6882,7 +6859,7 @@ func (l *lexer) next() token {
 		case 68:
 			goto st205
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6891,12 +6868,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st214:
 		if p++; p == pe {
 			goto _test_eof214
@@ -6906,7 +6883,7 @@ func (l *lexer) next() token {
 		case 84:
 			goto st206
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6915,12 +6892,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr165
+		goto tr164
 	st215:
 		if p++; p == pe {
 			goto _test_eof215
@@ -6932,7 +6909,7 @@ func (l *lexer) next() token {
 		case 77:
 			goto st212
 		case 95:
-			goto tr138
+			goto tr136
 		}
 		switch {
 		case data[p] < 65:
@@ -6941,12 +6918,12 @@ func (l *lexer) next() token {
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st216:
 		if p++; p == pe {
 			goto _test_eof216
@@ -6956,23 +6933,23 @@ func (l *lexer) next() token {
 		case 69:
 			goto st217
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
 			goto st217
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st217:
 		if p++; p == pe {
 			goto _test_eof217
@@ -6982,23 +6959,23 @@ func (l *lexer) next() token {
 		case 76:
 			goto st218
 		case 95:
-			goto tr138
+			goto tr136
 		case 108:
 			goto st218
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st218:
 		if p++; p == pe {
 			goto _test_eof218
@@ -7008,23 +6985,23 @@ func (l *lexer) next() token {
 		case 69:
 			goto st219
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
 			goto st219
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st219:
 		if p++; p == pe {
 			goto _test_eof219
@@ -7034,23 +7011,23 @@ func (l *lexer) next() token {
 		case 67:
 			goto st220
 		case 95:
-			goto tr138
+			goto tr136
 		case 99:
 			goto st220
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st220:
 		if p++; p == pe {
 			goto _test_eof220
@@ -7058,25 +7035,25 @@ func (l *lexer) next() token {
 	st_case_220:
 		switch data[p] {
 		case 84:
-			goto tr285
+			goto tr283
 		case 95:
-			goto tr138
+			goto tr136
 		case 116:
-			goto tr285
+			goto tr283
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st221:
 		if p++; p == pe {
 			goto _test_eof221
@@ -7088,7 +7065,7 @@ func (l *lexer) next() token {
 		case 82:
 			goto st225
 		case 95:
-			goto tr138
+			goto tr136
 		case 111:
 			goto st222
 		case 114:
@@ -7097,16 +7074,16 @@ func (l *lexer) next() token {
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st222:
 		if p++; p == pe {
 			goto _test_eof222
@@ -7116,23 +7093,23 @@ func (l *lexer) next() token {
 		case 75:
 			goto st223
 		case 95:
-			goto tr138
+			goto tr136
 		case 107:
 			goto st223
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st223:
 		if p++; p == pe {
 			goto _test_eof223
@@ -7142,23 +7119,23 @@ func (l *lexer) next() token {
 		case 69:
 			goto st224
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
 			goto st224
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st224:
 		if p++; p == pe {
 			goto _test_eof224
@@ -7166,25 +7143,25 @@ func (l *lexer) next() token {
 	st_case_224:
 		switch data[p] {
 		case 78:
-			goto tr290
+			goto tr288
 		case 95:
-			goto tr138
+			goto tr136
 		case 110:
-			goto tr290
+			goto tr288
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st225:
 		if p++; p == pe {
 			goto _test_eof225
@@ -7194,23 +7171,23 @@ func (l *lexer) next() token {
 		case 85:
 			goto st180
 		case 95:
-			goto tr138
+			goto tr136
 		case 117:
 			goto st180
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st226:
 		if p++; p == pe {
 			goto _test_eof226
@@ -7222,7 +7199,7 @@ func (l *lexer) next() token {
 		case 83:
 			goto st231
 		case 95:
-			goto tr138
+			goto tr136
 		case 112:
 			goto st227
 		case 115:
@@ -7231,16 +7208,16 @@ func (l *lexer) next() token {
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st227:
 		if p++; p == pe {
 			goto _test_eof227
@@ -7250,23 +7227,23 @@ func (l *lexer) next() token {
 		case 68:
 			goto st228
 		case 95:
-			goto tr138
+			goto tr136
 		case 100:
 			goto st228
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st228:
 		if p++; p == pe {
 			goto _test_eof228
@@ -7276,23 +7253,23 @@ func (l *lexer) next() token {
 		case 65:
 			goto st229
 		case 95:
-			goto tr138
+			goto tr136
 		case 97:
 			goto st229
 		}
 		switch {
 		case data[p] < 66:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 98 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st229:
 		if p++; p == pe {
 			goto _test_eof229
@@ -7302,23 +7279,23 @@ func (l *lexer) next() token {
 		case 84:
 			goto st230
 		case 95:
-			goto tr138
+			goto tr136
 		case 116:
 			goto st230
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st230:
 		if p++; p == pe {
 			goto _test_eof230
@@ -7326,25 +7303,25 @@ func (l *lexer) next() token {
 	st_case_230:
 		switch data[p] {
 		case 69:
-			goto tr296
+			goto tr294
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
-			goto tr296
+			goto tr294
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st231:
 		if p++; p == pe {
 			goto _test_eof231
@@ -7352,29 +7329,29 @@ func (l *lexer) next() token {
 	st_case_231:
 		switch data[p] {
 		case 69:
-			goto tr297
+			goto tr295
 		case 73:
 			goto st232
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
-			goto tr297
+			goto tr295
 		case 105:
 			goto st232
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st232:
 		if p++; p == pe {
 			goto _test_eof232
@@ -7384,23 +7361,23 @@ func (l *lexer) next() token {
 		case 78:
 			goto st233
 		case 95:
-			goto tr138
+			goto tr136
 		case 110:
 			goto st233
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st233:
 		if p++; p == pe {
 			goto _test_eof233
@@ -7408,25 +7385,25 @@ func (l *lexer) next() token {
 	st_case_233:
 		switch data[p] {
 		case 71:
-			goto tr300
+			goto tr298
 		case 95:
-			goto tr138
+			goto tr136
 		case 103:
-			goto tr300
+			goto tr298
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st234:
 		if p++; p == pe {
 			goto _test_eof234
@@ -7436,23 +7413,23 @@ func (l *lexer) next() token {
 		case 72:
 			goto st235
 		case 95:
-			goto tr138
+			goto tr136
 		case 104:
 			goto st235
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st235:
 		if p++; p == pe {
 			goto _test_eof235
@@ -7462,23 +7439,23 @@ func (l *lexer) next() token {
 		case 69:
 			goto st236
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
 			goto st236
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st236:
 		if p++; p == pe {
 			goto _test_eof236
@@ -7488,23 +7465,23 @@ func (l *lexer) next() token {
 		case 82:
 			goto st237
 		case 95:
-			goto tr138
+			goto tr136
 		case 114:
 			goto st237
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st237:
 		if p++; p == pe {
 			goto _test_eof237
@@ -7512,26 +7489,29 @@ func (l *lexer) next() token {
 	st_case_237:
 		switch data[p] {
 		case 69:
-			goto tr304
+			goto tr302
 		case 95:
-			goto tr138
+			goto tr136
 		case 101:
-			goto tr304
+			goto tr302
 		}
 		switch {
 		case data[p] < 65:
 			if 48 <= data[p] && data[p] <= 57 {
-				goto tr138
+				goto tr136
 			}
 		case data[p] > 90:
 			if 97 <= data[p] && data[p] <= 122 {
-				goto tr138
+				goto tr136
 			}
 		default:
-			goto tr138
+			goto tr136
 		}
-		goto tr195
+		goto tr150
 	st_out:
+	_test_eof89:
+		cs = 89
+		goto _test_eof
 	_test_eof90:
 		cs = 90
 		goto _test_eof
@@ -7541,20 +7521,17 @@ func (l *lexer) next() token {
 	_test_eof92:
 		cs = 92
 		goto _test_eof
-	_test_eof93:
-		cs = 93
-		goto _test_eof
 	_test_eof0:
 		cs = 0
 		goto _test_eof
-	_test_eof1:
-		cs = 1
+	_test_eof93:
+		cs = 93
 		goto _test_eof
 	_test_eof94:
 		cs = 94
 		goto _test_eof
-	_test_eof2:
-		cs = 2
+	_test_eof1:
+		cs = 1
 		goto _test_eof
 	_test_eof95:
 		cs = 95
@@ -7562,8 +7539,8 @@ func (l *lexer) next() token {
 	_test_eof96:
 		cs = 96
 		goto _test_eof
-	_test_eof3:
-		cs = 3
+	_test_eof2:
+		cs = 2
 		goto _test_eof
 	_test_eof97:
 		cs = 97
@@ -7580,24 +7557,27 @@ func (l *lexer) next() token {
 	_test_eof101:
 		cs = 101
 		goto _test_eof
+	_test_eof3:
+		cs = 3
+		goto _test_eof
 	_test_eof4:
 		cs = 4
 		goto _test_eof
-	_test_eof5:
-		cs = 5
-		goto _test_eof
 	_test_eof102:
 		cs = 102
 		goto _test_eof
 	_test_eof103:
 		cs = 103
 		goto _test_eof
-	_test_eof6:
-		cs = 6
+	_test_eof5:
+		cs = 5
 		goto _test_eof
 	_test_eof104:
 		cs = 104
 		goto _test_eof
+	_test_eof6:
+		cs = 6
+		goto _test_eof
 	_test_eof7:
 		cs = 7
 		goto _test_eof
@@ -7628,12 +7608,12 @@ func (l *lexer) next() token {
 	_test_eof16:
 		cs = 16
 		goto _test_eof
-	_test_eof17:
-		cs = 17
-		goto _test_eof
 	_test_eof105:
 		cs = 105
 		goto _test_eof
+	_test_eof17:
+		cs = 17
+		goto _test_eof
 	_test_eof18:
 		cs = 18
 		goto _test_eof
@@ -7688,41 +7668,38 @@ func (l *lexer) next() token {
 	_test_eof35:
 		cs = 35
 		goto _test_eof
-	_test_eof36:
-		cs = 36
-		goto _test_eof
 	_test_eof106:
 		cs = 106
 		goto _test_eof
 	_test_eof107:
 		cs = 107
 		goto _test_eof
-	_test_eof37:
-		cs = 37
+	_test_eof36:
+		cs = 36
 		goto _test_eof
 	_test_eof108:
 		cs = 108
 		goto _test_eof
-	_test_eof38:
-		cs = 38
+	_test_eof37:
+		cs = 37
 		goto _test_eof
 	_test_eof109:
 		cs = 109
 		goto _test_eof
-	_test_eof39:
-		cs = 39
+	_test_eof38:
+		cs = 38
 		goto _test_eof
 	_test_eof110:
 		cs = 110
 		goto _test_eof
-	_test_eof40:
-		cs = 40
+	_test_eof39:
+		cs = 39
 		goto _test_eof
 	_test_eof111:
 		cs = 111
 		goto _test_eof
-	_test_eof41:
-		cs = 41
+	_test_eof40:
+		cs = 40
 		goto _test_eof
 	_test_eof112:
 		cs = 112
@@ -7748,6 +7725,9 @@ func (l *lexer) next() token {
 	_test_eof119:
 		cs = 119
 		goto _test_eof
+	_test_eof41:
+		cs = 41
+		goto _test_eof
 	_test_eof42:
 		cs = 42
 		goto _test_eof
@@ -7829,18 +7809,15 @@ func (l *lexer) next() token {
 	_test_eof68:
 		cs = 68
 		goto _test_eof
-	_test_eof69:
-		cs = 69
-		goto _test_eof
 	_test_eof120:
 		cs = 120
 		goto _test_eof
+	_test_eof69:
+		cs = 69
+		goto _test_eof
 	_test_eof70:
 		cs = 70
 		goto _test_eof
-	_test_eof71:
-		cs = 71
-		goto _test_eof
 	_test_eof121:
 		cs = 121
 		goto _test_eof
@@ -7853,93 +7830,93 @@ func (l *lexer) next() token {
 	_test_eof124:
 		cs = 124
 		goto _test_eof
-	_test_eof72:
-		cs = 72
+	_test_eof71:
+		cs = 71
 		goto _test_eof
 	_test_eof125:
 		cs = 125
 		goto _test_eof
+	_test_eof72:
+		cs = 72
+		goto _test_eof
 	_test_eof73:
 		cs = 73
 		goto _test_eof
-	_test_eof74:
-		cs = 74
-		goto _test_eof
 	_test_eof126:
 		cs = 126
 		goto _test_eof
-	_test_eof75:
-		cs = 75
+	_test_eof74:
+		cs = 74
 		goto _test_eof
 	_test_eof127:
 		cs = 127
 		goto _test_eof
+	_test_eof75:
+		cs = 75
+		goto _test_eof
 	_test_eof76:
 		cs = 76
 		goto _test_eof
-	_test_eof77:
-		cs = 77
-		goto _test_eof
 	_test_eof128:
 		cs = 128
 		goto _test_eof
-	_test_eof78:
-		cs = 78
+	_test_eof77:
+		cs = 77
 		goto _test_eof
 	_test_eof129:
 		cs = 129
 		goto _test_eof
+	_test_eof78:
+		cs = 78
+		goto _test_eof
 	_test_eof79:
 		cs = 79
 		goto _test_eof
-	_test_eof80:
-		cs = 80
-		goto _test_eof
 	_test_eof130:
 		cs = 130
 		goto _test_eof
-	_test_eof81:
-		cs = 81
+	_test_eof80:
+		cs = 80
 		goto _test_eof
 	_test_eof131:
 		cs = 131
 		goto _test_eof
+	_test_eof81:
+		cs = 81
+		goto _test_eof
 	_test_eof82:
 		cs = 82
 		goto _test_eof
-	_test_eof83:
-		cs = 83
-		goto _test_eof
 	_test_eof132:
 		cs = 132
 		goto _test_eof
-	_test_eof84:
-		cs = 84
+	_test_eof83:
+		cs = 83
 		goto _test_eof
 	_test_eof133:
 		cs = 133
 		goto _test_eof
+	_test_eof84:
+		cs = 84
+		goto _test_eof
 	_test_eof85:
 		cs = 85
 		goto _test_eof
-	_test_eof86:
-		cs = 86
-		goto _test_eof
 	_test_eof134:
 		cs = 134
 		goto _test_eof
-	_test_eof87:
-		cs = 87
+	_test_eof86:
+		cs = 86
 		goto _test_eof
 	_test_eof135:
 		cs = 135
 		goto _test_eof
+	_test_eof87:
+		cs = 87
+		goto _test_eof
 	_test_eof88:
 		cs = 88
 		goto _test_eof
-	_test_eof89:
-		cs = 89
-		goto _test_eof
 	_test_eof136:
 		cs = 136
 		goto _test_eof
@@ -8252,80 +8229,82 @@ func (l *lexer) next() token {
 		}
 		if p == eof {
 			switch cs {
+			case 90:
+				goto tr148
 			case 91:
-				goto tr150
+				goto tr148
 			case 92:
-				goto tr150
-			case 93:
-				goto tr0
+				goto tr148
 			case 0:
 				goto tr0
-			case 1:
-				goto tr0
-			case 94:
+			case 93:
 				goto tr150
-			case 2:
+			case 94:
+				goto tr148
+			case 1:
 				goto tr0
 			case 95:
-				goto tr152
+				goto tr151
 			case 96:
-				goto tr150
-			case 3:
+				goto tr148
+			case 2:
 				goto tr0
 			case 97:
-				goto tr152
+				goto tr151
 			case 98:
-				goto tr153
+				goto tr152
 			case 99:
-				goto tr155
+				goto tr154
 			case 100:
-				goto tr161
+				goto tr160
 			case 101:
-				goto tr164
-			case 4:
+				goto tr163
+			case 3:
 				goto tr0
-			case 5:
+			case 4:
 				goto tr0
 			case 102:
-				goto tr164
+				goto tr163
 			case 103:
-				goto tr165
-			case 6:
-				goto tr11
+				goto tr164
+			case 5:
+				goto tr9
 			case 104:
-				goto tr165
+				goto tr164
+			case 6:
+				goto tr0
 			case 7:
 				goto tr0
 			case 8:
-				goto tr0
+				goto tr15
 			case 9:
-				goto tr17
+				goto tr15
 			case 10:
-				goto tr17
+				goto tr15
 			case 11:
-				goto tr17
+				goto tr15
 			case 12:
-				goto tr17
+				goto tr15
 			case 13:
-				goto tr17
+				goto tr15
 			case 14:
-				goto tr17
+				goto tr15
 			case 15:
-				goto tr17
+				goto tr15
 			case 16:
-				goto tr17
-			case 17:
-				goto tr17
+				goto tr15
 			case 105:
-				goto tr165
+				goto tr164
+			case 17:
+				goto tr9
 			case 18:
-				goto tr11
+				goto tr9
 			case 19:
-				goto tr11
+				goto tr9
 			case 20:
-				goto tr11
+				goto tr9
 			case 21:
-				goto tr11
+				goto tr0
 			case 22:
 				goto tr0
 			case 23:
@@ -8353,47 +8332,47 @@ func (l *lexer) next() token {
 			case 34:
 				goto tr0
 			case 35:
-				goto tr0
-			case 36:
-				goto tr11
+				goto tr9
 			case 106:
-				goto tr165
+				goto tr164
 			case 107:
-				goto tr165
-			case 37:
-				goto tr11
+				goto tr164
+			case 36:
+				goto tr9
 			case 108:
-				goto tr165
-			case 38:
-				goto tr11
+				goto tr164
+			case 37:
+				goto tr9
 			case 109:
-				goto tr165
-			case 39:
-				goto tr11
+				goto tr164
+			case 38:
+				goto tr9
 			case 110:
-				goto tr165
-			case 40:
-				goto tr11
+				goto tr164
+			case 39:
+				goto tr9
 			case 111:
-				goto tr165
-			case 41:
-				goto tr11
+				goto tr164
+			case 40:
+				goto tr9
 			case 112:
-				goto tr161
+				goto tr160
 			case 113:
-				goto tr161
+				goto tr160
 			case 114:
-				goto tr161
+				goto tr160
 			case 115:
-				goto tr161
+				goto tr160
 			case 116:
-				goto tr161
+				goto tr160
 			case 117:
-				goto tr161
+				goto tr160
 			case 118:
-				goto tr161
+				goto tr160
 			case 119:
-				goto tr161
+				goto tr160
+			case 41:
+				goto tr0
 			case 42:
 				goto tr0
 			case 43:
@@ -8448,284 +8427,282 @@ func (l *lexer) next() token {
 				goto tr0
 			case 68:
 				goto tr0
-			case 69:
-				goto tr0
 			case 120:
-				goto tr165
+				goto tr164
+			case 69:
+				goto tr82
 			case 70:
-				goto tr84
-			case 71:
-				goto tr84
+				goto tr82
 			case 121:
-				goto tr164
+				goto tr163
 			case 122:
-				goto tr164
+				goto tr163
 			case 123:
-				goto tr164
+				goto tr163
 			case 124:
-				goto tr164
-			case 72:
+				goto tr163
+			case 71:
 				goto tr0
 			case 125:
-				goto tr165
+				goto tr164
+			case 72:
+				goto tr9
 			case 73:
-				goto tr11
-			case 74:
-				goto tr84
+				goto tr82
 			case 126:
-				goto tr164
-			case 75:
+				goto tr163
+			case 74:
 				goto tr0
 			case 127:
-				goto tr165
+				goto tr164
+			case 75:
+				goto tr9
 			case 76:
-				goto tr11
-			case 77:
-				goto tr84
+				goto tr82
 			case 128:
-				goto tr164
-			case 78:
+				goto tr163
+			case 77:
 				goto tr0
 			case 129:
-				goto tr165
+				goto tr164
+			case 78:
+				goto tr9
 			case 79:
-				goto tr11
-			case 80:
-				goto tr84
+				goto tr82
 			case 130:
-				goto tr164
-			case 81:
+				goto tr163
+			case 80:
 				goto tr0
 			case 131:
-				goto tr165
+				goto tr164
+			case 81:
+				goto tr9
 			case 82:
-				goto tr11
-			case 83:
-				goto tr84
+				goto tr82
 			case 132:
-				goto tr164
-			case 84:
+				goto tr163
+			case 83:
 				goto tr0
 			case 133:
-				goto tr165
+				goto tr164
+			case 84:
+				goto tr9
 			case 85:
-				goto tr11
-			case 86:
-				goto tr84
+				goto tr82
 			case 134:
+				goto tr163
+			case 86:
+				goto tr82
+			case 135:
 				goto tr164
 			case 87:
-				goto tr84
-			case 135:
-				goto tr165
+				goto tr9
 			case 88:
-				goto tr11
-			case 89:
-				goto tr84
+				goto tr82
 			case 136:
-				goto tr164
+				goto tr163
 			case 137:
-				goto tr190
+				goto tr189
 			case 138:
-				goto tr161
+				goto tr160
 			case 139:
-				goto tr191
+				goto tr190
 			case 140:
-				goto tr193
+				goto tr192
 			case 141:
-				goto tr195
+				goto tr150
 			case 142:
-				goto tr195
+				goto tr150
 			case 143:
-				goto tr195
+				goto tr150
 			case 144:
-				goto tr195
+				goto tr150
 			case 145:
-				goto tr195
+				goto tr150
 			case 146:
-				goto tr195
+				goto tr150
 			case 147:
-				goto tr195
+				goto tr150
 			case 148:
-				goto tr195
+				goto tr150
 			case 149:
 				goto tr0
 			case 150:
-				goto tr195
+				goto tr150
 			case 151:
-				goto tr195
+				goto tr150
 			case 152:
-				goto tr195
+				goto tr150
 			case 153:
-				goto tr195
+				goto tr150
 			case 154:
-				goto tr195
+				goto tr150
 			case 155:
-				goto tr195
+				goto tr150
 			case 156:
-				goto tr195
+				goto tr150
 			case 157:
-				goto tr195
+				goto tr150
 			case 158:
-				goto tr195
+				goto tr150
 			case 159:
-				goto tr195
+				goto tr150
 			case 160:
-				goto tr195
+				goto tr150
 			case 161:
-				goto tr195
+				goto tr150
 			case 162:
-				goto tr195
+				goto tr150
 			case 163:
-				goto tr195
+				goto tr150
 			case 164:
-				goto tr195
+				goto tr150
 			case 165:
-				goto tr195
+				goto tr150
 			case 166:
-				goto tr195
+				goto tr150
 			case 167:
-				goto tr195
+				goto tr150
 			case 168:
-				goto tr195
+				goto tr150
 			case 169:
-				goto tr195
+				goto tr150
 			case 170:
-				goto tr195
+				goto tr150
 			case 171:
-				goto tr195
+				goto tr150
 			case 172:
-				goto tr195
+				goto tr150
 			case 173:
-				goto tr195
+				goto tr150
 			case 174:
-				goto tr195
+				goto tr150
 			case 175:
-				goto tr195
+				goto tr150
 			case 176:
-				goto tr195
+				goto tr150
 			case 177:
-				goto tr195
+				goto tr150
 			case 178:
-				goto tr195
+				goto tr150
 			case 179:
-				goto tr195
+				goto tr150
 			case 180:
-				goto tr195
+				goto tr150
 			case 181:
-				goto tr195
+				goto tr150
 			case 182:
-				goto tr195
+				goto tr150
 			case 183:
-				goto tr195
+				goto tr150
 			case 184:
-				goto tr244
+				goto tr242
 			case 185:
-				goto tr195
+				goto tr150
 			case 186:
-				goto tr195
+				goto tr150
 			case 187:
-				goto tr195
+				goto tr150
 			case 188:
-				goto tr195
+				goto tr150
 			case 189:
-				goto tr195
+				goto tr150
 			case 190:
-				goto tr195
+				goto tr150
 			case 191:
-				goto tr195
+				goto tr150
 			case 192:
-				goto tr195
+				goto tr150
 			case 193:
-				goto tr195
+				goto tr150
 			case 194:
-				goto tr195
+				goto tr150
 			case 195:
-				goto tr195
+				goto tr150
 			case 196:
-				goto tr195
+				goto tr150
 			case 197:
-				goto tr195
+				goto tr150
 			case 198:
-				goto tr195
+				goto tr150
 			case 199:
-				goto tr165
+				goto tr164
 			case 200:
-				goto tr195
+				goto tr150
 			case 201:
-				goto tr195
+				goto tr150
 			case 202:
-				goto tr195
+				goto tr150
 			case 203:
-				goto tr195
+				goto tr150
 			case 204:
-				goto tr195
+				goto tr150
 			case 205:
-				goto tr165
+				goto tr164
 			case 206:
-				goto tr165
+				goto tr164
 			case 207:
-				goto tr195
+				goto tr150
 			case 208:
-				goto tr165
+				goto tr164
 			case 209:
-				goto tr195
+				goto tr150
 			case 210:
-				goto tr165
+				goto tr164
 			case 211:
-				goto tr195
+				goto tr150
 			case 212:
-				goto tr165
+				goto tr164
 			case 213:
-				goto tr195
+				goto tr150
 			case 214:
-				goto tr165
+				goto tr164
 			case 215:
-				goto tr195
+				goto tr150
 			case 216:
-				goto tr195
+				goto tr150
 			case 217:
-				goto tr195
+				goto tr150
 			case 218:
-				goto tr195
+				goto tr150
 			case 219:
-				goto tr195
+				goto tr150
 			case 220:
-				goto tr195
+				goto tr150
 			case 221:
-				goto tr195
+				goto tr150
 			case 222:
-				goto tr195
+				goto tr150
 			case 223:
-				goto tr195
+				goto tr150
 			case 224:
-				goto tr195
+				goto tr150
 			case 225:
-				goto tr195
+				goto tr150
 			case 226:
-				goto tr195
+				goto tr150
 			case 227:
-				goto tr195
+				goto tr150
 			case 228:
-				goto tr195
+				goto tr150
 			case 229:
-				goto tr195
+				goto tr150
 			case 230:
-				goto tr195
+				goto tr150
 			case 231:
-				goto tr195
+				goto tr150
 			case 232:
-				goto tr195
+				goto tr150
 			case 233:
-				goto tr195
+				goto tr150
 			case 234:
-				goto tr195
+				goto tr150
 			case 235:
-				goto tr195
+				goto tr150
 			case 236:
-				goto tr195
+				goto tr150
 			case 237:
-				goto tr195
+				goto tr150
 			}
 		}
 
diff --git a/parser/lexer.rl b/parser/lexer.rl
index ce7608e..603265c 100644
--- a/parser/lexer.rl
+++ b/parser/lexer.rl
@@ -133,7 +133,7 @@ func (l *lexer) next() token {
     %%{
         ws = [ \t];
         nl = '\r\n' | '\n';
-        id = ([a-zA-Z][a-zA-Z0-9_]*)|("\"" ([^\r\n\"] | "\\\"")* "\"");
+        id = ([a-zA-Z][a-zA-Z0-9_]*)|("\"" ([^\r\n\"] | "\"\"")* "\"");
         integer = '-'? digit+;
         exponent = [eE] ('+' | '-')? digit+;
         float = (integer exponent) | (integer '.' digit* exponent?);
diff --git a/parser/lexer_test.go b/parser/lexer_test.go
index 1945943..85810bf 100644
--- a/parser/lexer_test.go
+++ b/parser/lexer_test.go
@@ -73,3 +73,38 @@ func TestLexerLiterals(t *testing.T) {
 		assert.Equal(t, tt.tk, l.next(), fmt.Sprintf("failed on literal: %s", tt.literal))
 	}
 }
+
+func TestLexerIdentifiers(t *testing.T) {
+	var tests = []struct {
+		literal  string
+		tk       token
+		expected string
+	}{
+		{`system`, tkIdentifier, "system"},
+		{`sys"tem`, tkIdentifier, "sys"},
+		{`System`, tkIdentifier, "system"},
+		{`"system"`, tkIdentifier, "system"},
+		{`"system"`, tkIdentifier, "system"},
+		{`"System"`, tkIdentifier, "System"},
+		{`""""`, tkIdentifier, "\""},
+		{`""""""`, tkIdentifier, "\"\""},
+		{`"A"""""`, tkIdentifier, "A\"\""},
+		{`"""A"""`, tkIdentifier, "\"A\""},
+		{`"""""A"`, tkIdentifier, "\"\"A"},
+		{`";`, tkInvalid, ""},
+		{`"""`, tkIdentifier, ""},
+	}
+
+	for _, tt := range tests {
+		var l lexer
+		l.init(tt.literal)
+		n := l.next()
+		assert.Equal(t, tt.tk, n, fmt.Sprintf("failed on literal: %s", tt.literal))
+		if n == tkIdentifier {
+			id := l.identifier()
+			if id.ID() != tt.expected {
+				t.Errorf("expected %s, got %s", tt.expected, l.id)
+			}
+		}
+	}
+}
diff --git a/proxy/proxy.go b/proxy/proxy.go
index a9f2a89..57443cb 100644
--- a/proxy/proxy.go
+++ b/proxy/proxy.go
@@ -816,7 +816,8 @@ func (c *client) interceptSystemQuery(hdr *frame.Header, stmt interface{}) {
 			c.send(hdr, &message.ServerError{ErrorMessage: "Proxy unable to create new session for keyspace"})
 		} else {
 			c.keyspace = s.Keyspace
-			c.send(hdr, &message.SetKeyspaceResult{Keyspace: s.Keyspace})
+			ks := parser.IdentifierFromString(s.Keyspace)
+			c.send(hdr, &message.SetKeyspaceResult{Keyspace: ks.ID()})
 		}
 	default:
 		c.send(hdr, &message.ServerError{ErrorMessage: "Proxy attempted to intercept an unhandled query"})