diff --git a/freefloating/position_string.go b/freefloating/position_string.go
index d10a397..56e8324 100644
--- a/freefloating/position_string.go
+++ b/freefloating/position_string.go
@@ -4,9 +4,9 @@ package freefloating
 
 import "strconv"
 
-const _Position_name = "StartEndSlashColonSemiColonAltEndDollarAmpersandNamePrefixKeyVarUseTypeReturnTypeOptionalTypeCaseSeparatorLexicalVarsParamsRefCastExprInitExprCondExprIncExprTrueCondHaltCompillerNamespaceStaticClassUseWhileForSwitchBreakForeachDeclareLabelFinallyListDefaultIfElseIfElseVariadicFunctionAliasAsEqualExitArrayIssetEmptyEvalEchoTryCatchUnsetStmtsVarListConstListNameListParamListModifierListArrayPairListCaseListStartCaseListEndArgumentListPropertyListParameterListAdaptationListLexicalVarListUseDeclarationListOpenParenthesisTokenCloseParenthesisToken"
+const _Position_name = "StartEndSlashColonSemiColonAltEndDollarAmpersandNamePrefixKeyVarUseTypeReturnTypeOptionalTypeCaseSeparatorLexicalVarsParamsRefCastExprInitExprCondExprIncExprTrueCondHaltCompillerNamespaceStaticClassUseWhileForSwitchBreakForeachDeclareLabelFinallyListDefaultIfElseIfElseVariadicFunctionDoubleArrowAliasAsEqualExitArrayIssetEmptyEvalEchoTryCatchUnsetStmtsVarListConstListNameListParamListModifierListArrayPairListCaseListStartCaseListEndArgumentListPropertyListParameterListAdaptationListLexicalVarListUseDeclarationListOpenParenthesisTokenCloseParenthesisToken"
 
-var _Position_index = [...]uint16{0, 5, 8, 13, 18, 27, 33, 39, 48, 52, 58, 61, 64, 71, 81, 93, 106, 117, 123, 126, 130, 134, 142, 150, 157, 161, 165, 178, 187, 193, 198, 201, 206, 209, 215, 220, 227, 234, 239, 246, 250, 257, 259, 265, 269, 277, 285, 290, 292, 297, 301, 306, 311, 316, 320, 324, 327, 332, 337, 342, 349, 358, 366, 375, 387, 400, 413, 424, 436, 448, 461, 475, 489, 507, 527, 548}
+var _Position_index = [...]uint16{0, 5, 8, 13, 18, 27, 33, 39, 48, 52, 58, 61, 64, 71, 81, 93, 106, 117, 123, 126, 130, 134, 142, 150, 157, 161, 165, 178, 187, 193, 198, 201, 206, 209, 215, 220, 227, 234, 239, 246, 250, 257, 259, 265, 269, 277, 285, 296, 301, 303, 308, 312, 317, 322, 327, 331, 335, 338, 343, 348, 353, 360, 369, 377, 386, 398, 411, 424, 435, 447, 459, 472, 486, 500, 518, 538, 559}
 
 func (i Position) String() string {
 	if i < 0 || i >= Position(len(_Position_index)-1) {
diff --git a/freefloating/string.go b/freefloating/string.go
index be5507f..ee05c36 100644
--- a/freefloating/string.go
+++ b/freefloating/string.go
@@ -61,6 +61,7 @@ const (
 	Else
 	Variadic
 	Function
+	DoubleArrow
 	Alias
 	As
 	Equal
diff --git a/node/expr/assign/n_coalesce.go b/node/expr/assign/n_coalesce.go
new file mode 100644
index 0000000..40db8e9
--- /dev/null
+++ b/node/expr/assign/n_coalesce.go
@@ -0,0 +1,66 @@
+package assign
+
+import (
+	"github.com/z7zmey/php-parser/freefloating"
+	"github.com/z7zmey/php-parser/node"
+	"github.com/z7zmey/php-parser/position"
+	"github.com/z7zmey/php-parser/walker"
+)
+
+// Coalesce node
+type Coalesce struct {
+	FreeFloating freefloating.Collection
+	Position     *position.Position
+	Variable     node.Node
+	Expression   node.Node
+}
+
+// NewCoalesce node constructor
+func NewCoalesce(Variable node.Node, Expression node.Node) *Coalesce {
+	return &Coalesce{
+		FreeFloating: nil,
+		Variable:     Variable,
+		Expression:   Expression,
+	}
+}
+
+// SetPosition sets node position
+func (n *Coalesce) SetPosition(p *position.Position) {
+	n.Position = p
+}
+
+// GetPosition returns node positions
+func (n *Coalesce) GetPosition() *position.Position {
+	return n.Position
+}
+
+func (n *Coalesce) GetFreeFloating() *freefloating.Collection {
+	return &n.FreeFloating
+}
+
+// Attributes returns node attributes as map
+func (n *Coalesce) Attributes() map[string]interface{} {
+	return nil
+}
+
+// Walk traverses nodes
+// Walk is invoked recursively until v.EnterNode returns true
+func (n *Coalesce) Walk(v walker.Visitor) {
+	if v.EnterNode(n) == false {
+		return
+	}
+
+	if n.Variable != nil {
+		v.EnterChildNode("Variable", n)
+		n.Variable.Walk(v)
+		v.LeaveChildNode("Variable", n)
+	}
+
+	if n.Expression != nil {
+		v.EnterChildNode("Expression", n)
+		n.Expression.Walk(v)
+		v.LeaveChildNode("Expression", n)
+	}
+
+	v.LeaveNode(n)
+}
diff --git a/node/expr/assign/t_assign_op_test.go b/node/expr/assign/t_assign_op_test.go
index afbd8bf..3a57089 100644
--- a/node/expr/assign/t_assign_op_test.go
+++ b/node/expr/assign/t_assign_op_test.go
@@ -1272,3 +1272,73 @@ func TestShiftRight(t *testing.T) {
 	actual = php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
 }
+
+func TestCoalesce(t *testing.T) {
+	src := `<? $a ??= $b;`
+
+	expected := &node.Root{
+		Position: &position.Position{
+			StartLine: 1,
+			EndLine:   1,
+			StartPos:  3,
+			EndPos:    13,
+		},
+		Stmts: []node.Node{
+			&stmt.Expression{
+				Position: &position.Position{
+					StartLine: 1,
+					EndLine:   1,
+					StartPos:  3,
+					EndPos:    13,
+				},
+				Expr: &assign.Coalesce{
+					Position: &position.Position{
+						StartLine: 1,
+						EndLine:   1,
+						StartPos:  3,
+						EndPos:    12,
+					},
+					Variable: &expr.Variable{
+						Position: &position.Position{
+							StartLine: 1,
+							EndLine:   1,
+							StartPos:  3,
+							EndPos:    5,
+						},
+						VarName: &node.Identifier{
+							Position: &position.Position{
+								StartLine: 1,
+								EndLine:   1,
+								StartPos:  3,
+								EndPos:    5,
+							},
+							Value: "a",
+						},
+					},
+					Expression: &expr.Variable{
+						Position: &position.Position{
+							StartLine: 1,
+							EndLine:   1,
+							StartPos:  10,
+							EndPos:    12,
+						},
+						VarName: &node.Identifier{
+							Position: &position.Position{
+								StartLine: 1,
+								EndLine:   1,
+								StartPos:  10,
+								EndPos:    12,
+							},
+							Value: "b",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	php7parser := php7.NewParser([]byte(src), "7.4")
+	php7parser.Parse()
+	actual := php7parser.GetRootNode()
+	assert.DeepEqual(t, expected, actual)
+}
diff --git a/node/expr/assign/t_freefloating_test.go b/node/expr/assign/t_freefloating_test.go
index 151ac20..769778a 100644
--- a/node/expr/assign/t_freefloating_test.go
+++ b/node/expr/assign/t_freefloating_test.go
@@ -41,6 +41,9 @@ var nodes = []node.Node{
 	&assign.BitwiseXor{
 		FreeFloating: expected,
 	},
+	&assign.Coalesce{
+		FreeFloating: expected,
+	},
 	&assign.Concat{
 		FreeFloating: expected,
 	},
diff --git a/node/expr/assign/t_visitor_test.go b/node/expr/assign/t_visitor_test.go
index 6694b5b..800dcbb 100644
--- a/node/expr/assign/t_visitor_test.go
+++ b/node/expr/assign/t_visitor_test.go
@@ -56,6 +56,14 @@ var nodesToTest = []struct {
 		[]string{"Variable", "Expression"},
 		nil,
 	},
+	{
+		&assign.Coalesce{
+			Variable:   &expr.Variable{},
+			Expression: &expr.Variable{},
+		},
+		[]string{"Variable", "Expression"},
+		nil,
+	},
 	{
 		&assign.Concat{
 			Variable:   &expr.Variable{},
diff --git a/node/expr/n_arrow_function.go b/node/expr/n_arrow_function.go
new file mode 100644
index 0000000..d43e1e8
--- /dev/null
+++ b/node/expr/n_arrow_function.go
@@ -0,0 +1,88 @@
+package expr
+
+import (
+	"github.com/z7zmey/php-parser/freefloating"
+	"github.com/z7zmey/php-parser/node"
+	"github.com/z7zmey/php-parser/position"
+	"github.com/z7zmey/php-parser/walker"
+)
+
+// ArrowFunction node
+type ArrowFunction struct {
+	FreeFloating  freefloating.Collection
+	Position      *position.Position
+	ReturnsRef    bool
+	Static        bool
+	PhpDocComment string
+	Params        []node.Node
+	ReturnType    node.Node
+	Expr          node.Node
+}
+
+// NewArrowFunction node constructor
+func NewArrowFunction(Params []node.Node, ReturnType node.Node, Stmt node.Node, Static bool, ReturnsRef bool, PhpDocComment string) *ArrowFunction {
+	return &ArrowFunction{
+		FreeFloating:  nil,
+		ReturnsRef:    ReturnsRef,
+		Static:        Static,
+		PhpDocComment: PhpDocComment,
+		Params:        Params,
+		ReturnType:    ReturnType,
+		Expr:          Stmt,
+	}
+}
+
+// SetPosition sets node position
+func (n *ArrowFunction) SetPosition(p *position.Position) {
+	n.Position = p
+}
+
+// GetPosition returns node positions
+func (n *ArrowFunction) GetPosition() *position.Position {
+	return n.Position
+}
+
+func (n *ArrowFunction) GetFreeFloating() *freefloating.Collection {
+	return &n.FreeFloating
+}
+
+// Attributes returns node attributes as map
+func (n *ArrowFunction) Attributes() map[string]interface{} {
+	return map[string]interface{}{
+		"ReturnsRef":    n.ReturnsRef,
+		"Static":        n.Static,
+		"PhpDocComment": n.PhpDocComment,
+	}
+}
+
+// Walk traverses nodes
+// Walk is invoked recursively until v.EnterNode returns true
+func (n *ArrowFunction) Walk(v walker.Visitor) {
+	if v.EnterNode(n) == false {
+		return
+	}
+
+	if n.Params != nil {
+		v.EnterChildList("Params", n)
+		for _, nn := range n.Params {
+			if nn != nil {
+				nn.Walk(v)
+			}
+		}
+		v.LeaveChildList("Params", n)
+	}
+
+	if n.ReturnType != nil {
+		v.EnterChildNode("ReturnType", n)
+		n.ReturnType.Walk(v)
+		v.LeaveChildNode("ReturnType", n)
+	}
+
+	if n.Expr != nil {
+		v.EnterChildNode("Expr", n)
+		n.Expr.Walk(v)
+		v.LeaveChildNode("Expr", n)
+	}
+
+	v.LeaveNode(n)
+}
diff --git a/node/expr/t_arrow_function_test.go b/node/expr/t_arrow_function_test.go
new file mode 100644
index 0000000..40211c2
--- /dev/null
+++ b/node/expr/t_arrow_function_test.go
@@ -0,0 +1,144 @@
+package expr_test
+
+import (
+	"testing"
+
+	"github.com/z7zmey/php-parser/node"
+	"github.com/z7zmey/php-parser/node/expr"
+	"github.com/z7zmey/php-parser/node/name"
+	"github.com/z7zmey/php-parser/node/stmt"
+	"github.com/z7zmey/php-parser/php7"
+	"github.com/z7zmey/php-parser/position"
+	"gotest.tools/assert"
+)
+
+func TestArrowFunction(t *testing.T) {
+	src := `<? fn() => $a;`
+
+	expected := &node.Root{
+		Position: &position.Position{
+			StartLine: 1,
+			EndLine:   1,
+			StartPos:  3,
+			EndPos:    14,
+		},
+		Stmts: []node.Node{
+			&stmt.Expression{
+				Position: &position.Position{
+					StartLine: 1,
+					EndLine:   1,
+					StartPos:  3,
+					EndPos:    14,
+				},
+				Expr: &expr.ArrowFunction{
+					Position: &position.Position{
+						StartLine: 1,
+						EndLine:   1,
+						StartPos:  3,
+						EndPos:    13,
+					},
+					ReturnsRef:    false,
+					Static:        false,
+					PhpDocComment: "",
+					Expr: &expr.Variable{
+						Position: &position.Position{
+							StartLine: 1,
+							EndLine:   1,
+							StartPos:  11,
+							EndPos:    13,
+						},
+						VarName: &node.Identifier{
+							Position: &position.Position{
+								StartLine: 1,
+								EndLine:   1,
+								StartPos:  11,
+								EndPos:    13,
+							},
+							Value: "a",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	php7parser := php7.NewParser([]byte(src), "7.4")
+	php7parser.Parse()
+	actual := php7parser.GetRootNode()
+	assert.DeepEqual(t, expected, actual)
+}
+
+func TestArrowFunctionReturnType(t *testing.T) {
+	src := `<? fn & () : foo => $a;`
+
+	expected := &node.Root{
+		Position: &position.Position{
+			StartLine: 1,
+			EndLine:   1,
+			StartPos:  3,
+			EndPos:    23,
+		},
+		Stmts: []node.Node{
+			&stmt.Expression{
+				Position: &position.Position{
+					StartLine: 1,
+					EndLine:   1,
+					StartPos:  3,
+					EndPos:    23,
+				},
+				Expr: &expr.ArrowFunction{
+					Position: &position.Position{
+						StartLine: 1,
+						EndLine:   1,
+						StartPos:  3,
+						EndPos:    22,
+					},
+					Static:        false,
+					PhpDocComment: "",
+					ReturnsRef:    true,
+					ReturnType: &name.Name{
+						Position: &position.Position{
+							StartLine: 1,
+							EndLine:   1,
+							StartPos:  13,
+							EndPos:    16,
+						},
+						Parts: []node.Node{
+							&name.NamePart{
+								Position: &position.Position{
+									StartLine: 1,
+									EndLine:   1,
+									StartPos:  13,
+									EndPos:    16,
+								},
+								Value: "foo",
+							},
+						},
+					},
+					Expr: &expr.Variable{
+						Position: &position.Position{
+							StartLine: 1,
+							EndLine:   1,
+							StartPos:  20,
+							EndPos:    22,
+						},
+						VarName: &node.Identifier{
+							Position: &position.Position{
+								StartLine: 1,
+								EndLine:   1,
+								StartPos:  20,
+								EndPos:    22,
+							},
+							Value: "a",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	php7parser := php7.NewParser([]byte(src), "7.4")
+	php7parser.Parse()
+	actual := php7parser.GetRootNode()
+	assert.DeepEqual(t, expected, actual)
+}
diff --git a/node/expr/t_freefloating_test.go b/node/expr/t_freefloating_test.go
index 92291d1..4a7f2b6 100644
--- a/node/expr/t_freefloating_test.go
+++ b/node/expr/t_freefloating_test.go
@@ -35,6 +35,9 @@ var nodes = []node.Node{
 	&expr.Array{
 		FreeFloating: expected,
 	},
+	&expr.ArrowFunction{
+		FreeFloating: expected,
+	},
 	&expr.BitwiseNot{
 		FreeFloating: expected,
 	},
diff --git a/node/expr/t_visitor_test.go b/node/expr/t_visitor_test.go
index ab28817..849e6e0 100644
--- a/node/expr/t_visitor_test.go
+++ b/node/expr/t_visitor_test.go
@@ -97,6 +97,18 @@ var nodesToTest = []struct {
 		[]string{"Params", "ClosureUse", "ReturnType", "Stmts"},
 		map[string]interface{}{"ReturnsRef": true, "Static": false, "PhpDocComment": ""},
 	},
+	{
+		&expr.ArrowFunction{
+			ReturnsRef:    true,
+			Static:        false,
+			PhpDocComment: "",
+			Params:        []node.Node{&node.Parameter{}},
+			ReturnType:    &name.Name{},
+			Expr:          &expr.Variable{},
+		},
+		[]string{"Params", "ReturnType", "Expr"},
+		map[string]interface{}{"ReturnsRef": true, "Static": false, "PhpDocComment": ""},
+	},
 	{
 		&expr.ConstFetch{
 			Constant: &node.Identifier{Value: "foo"},
diff --git a/php7/php7.go b/php7/php7.go
index fee9e3a..c8fc4cd 100644
--- a/php7/php7.go
+++ b/php7/php7.go
@@ -350,7 +350,7 @@ const yyEofCode = 1
 const yyErrCode = 2
 const yyInitialStackSize = 16
 
-//line php7/php7.y:5616
+//line php7/php7.y:5654
 
 //line yacctab:1
 var yyExca = [...]int{
@@ -361,1015 +361,1007 @@ var yyExca = [...]int{
 	1, 1,
 	-2, 0,
 	-1, 44,
-	58, 422,
-	79, 422,
-	144, 422,
-	150, 422,
-	-2, 417,
+	58, 426,
+	79, 426,
+	144, 426,
+	150, 426,
+	-2, 421,
 	-1, 48,
-	148, 425,
-	-2, 434,
-	-1, 84,
-	58, 424,
-	79, 424,
-	144, 424,
-	148, 427,
-	150, 424,
-	-2, 412,
-	-1, 107,
-	79, 385,
-	-2, 414,
-	-1, 229,
-	58, 422,
-	79, 422,
-	144, 422,
-	150, 422,
-	-2, 313,
+	148, 429,
+	-2, 438,
+	-1, 85,
+	58, 428,
+	79, 428,
+	144, 428,
+	148, 431,
+	150, 428,
+	-2, 416,
+	-1, 109,
+	79, 389,
+	-2, 418,
 	-1, 232,
-	148, 427,
-	-2, 424,
-	-1, 235,
-	58, 422,
-	79, 422,
-	144, 422,
-	150, 422,
+	58, 426,
+	79, 426,
+	144, 426,
+	150, 426,
 	-2, 315,
-	-1, 354,
-	116, 0,
-	136, 0,
-	137, 0,
-	138, 0,
-	139, 0,
-	-2, 337,
-	-1, 355,
-	116, 0,
-	136, 0,
-	137, 0,
-	138, 0,
-	139, 0,
-	-2, 338,
-	-1, 356,
-	116, 0,
-	136, 0,
-	137, 0,
-	138, 0,
-	139, 0,
-	-2, 339,
+	-1, 235,
+	148, 431,
+	-2, 428,
+	-1, 238,
+	58, 426,
+	79, 426,
+	144, 426,
+	150, 426,
+	-2, 317,
 	-1, 357,
 	116, 0,
 	136, 0,
 	137, 0,
 	138, 0,
 	139, 0,
-	-2, 340,
+	-2, 339,
 	-1, 358,
-	140, 0,
-	141, 0,
-	167, 0,
-	168, 0,
-	-2, 341,
-	-1, 359,
-	140, 0,
-	141, 0,
-	167, 0,
-	168, 0,
-	-2, 342,
-	-1, 360,
-	140, 0,
-	141, 0,
-	167, 0,
-	168, 0,
-	-2, 343,
-	-1, 361,
-	140, 0,
-	141, 0,
-	167, 0,
-	168, 0,
-	-2, 344,
-	-1, 362,
 	116, 0,
 	136, 0,
 	137, 0,
 	138, 0,
 	139, 0,
+	-2, 340,
+	-1, 359,
+	116, 0,
+	136, 0,
+	137, 0,
+	138, 0,
+	139, 0,
+	-2, 341,
+	-1, 360,
+	116, 0,
+	136, 0,
+	137, 0,
+	138, 0,
+	139, 0,
+	-2, 342,
+	-1, 361,
+	140, 0,
+	141, 0,
+	167, 0,
+	168, 0,
+	-2, 343,
+	-1, 362,
+	140, 0,
+	141, 0,
+	167, 0,
+	168, 0,
+	-2, 344,
+	-1, 363,
+	140, 0,
+	141, 0,
+	167, 0,
+	168, 0,
 	-2, 345,
-	-1, 369,
-	149, 163,
-	160, 163,
-	-2, 422,
-	-1, 413,
-	149, 462,
-	151, 462,
-	160, 462,
-	-2, 422,
-	-1, 417,
-	58, 423,
-	79, 423,
-	144, 423,
-	148, 426,
-	150, 423,
+	-1, 364,
+	140, 0,
+	141, 0,
+	167, 0,
+	168, 0,
+	-2, 346,
+	-1, 365,
+	116, 0,
+	136, 0,
+	137, 0,
+	138, 0,
+	139, 0,
 	-2, 347,
-	-1, 431,
-	148, 448,
-	-2, 415,
-	-1, 432,
-	148, 450,
-	-2, 440,
-	-1, 511,
-	148, 448,
-	-2, 416,
-	-1, 512,
-	148, 450,
-	-2, 441,
-	-1, 571,
-	149, 213,
-	-2, 218,
-	-1, 596,
-	148, 426,
-	-2, 423,
-	-1, 648,
-	149, 213,
-	-2, 218,
-	-1, 653,
-	149, 183,
-	-2, 422,
-	-1, 661,
-	149, 213,
-	-2, 218,
-	-1, 686,
-	149, 461,
-	151, 461,
-	160, 461,
-	-2, 422,
-	-1, 719,
+	-1, 372,
+	149, 164,
+	160, 164,
+	-2, 426,
+	-1, 417,
+	149, 466,
+	151, 466,
+	160, 466,
+	-2, 426,
+	-1, 421,
+	58, 427,
+	79, 427,
+	144, 427,
+	148, 430,
+	150, 427,
+	-2, 349,
+	-1, 435,
+	148, 452,
+	-2, 419,
+	-1, 436,
+	148, 454,
+	-2, 444,
+	-1, 516,
+	148, 452,
+	-2, 420,
+	-1, 517,
+	148, 454,
+	-2, 445,
+	-1, 534,
+	149, 214,
+	-2, 219,
+	-1, 576,
+	149, 214,
+	-2, 219,
+	-1, 601,
+	148, 430,
+	-2, 427,
+	-1, 667,
 	149, 184,
-	-2, 422,
-	-1, 739,
-	12, 265,
-	-2, 268,
-	-1, 753,
-	94, 208,
-	95, 208,
-	96, 208,
-	-2, 0,
-	-1, 778,
-	149, 183,
-	-2, 422,
-	-1, 780,
-	149, 186,
-	-2, 396,
-	-1, 800,
+	-2, 426,
+	-1, 675,
+	149, 214,
+	-2, 219,
+	-1, 691,
+	149, 465,
+	151, 465,
+	160, 465,
+	-2, 426,
+	-1, 728,
+	149, 185,
+	-2, 426,
+	-1, 744,
+	12, 266,
+	-2, 269,
+	-1, 758,
 	94, 209,
 	95, 209,
 	96, 209,
 	-2, 0,
-	-1, 849,
+	-1, 787,
+	149, 184,
+	-2, 426,
+	-1, 789,
+	149, 187,
+	-2, 400,
+	-1, 806,
+	94, 210,
+	95, 210,
+	96, 210,
+	-2, 0,
+	-1, 857,
+	31, 200,
+	32, 200,
+	33, 200,
+	145, 200,
+	-2, 0,
+	-1, 887,
+	29, 77,
+	-2, 81,
+	-1, 892,
 	31, 199,
 	32, 199,
 	33, 199,
 	145, 199,
 	-2, 0,
-	-1, 882,
-	29, 76,
-	-2, 80,
-	-1, 885,
-	31, 198,
-	32, 198,
-	33, 198,
-	145, 198,
-	-2, 0,
-	-1, 914,
-	149, 213,
-	-2, 218,
+	-1, 918,
+	149, 214,
+	-2, 219,
 }
 
 const yyPrivate = 57344
 
-const yyLast = 7732
+const yyLast = 7654
 
 var yyAct = [...]int{
 
-	28, 130, 825, 838, 662, 861, 376, 578, 741, 436,
-	874, 107, 837, 793, 774, 666, 811, 675, 785, 126,
-	652, 633, 138, 138, 138, 664, 221, 151, 711, 565,
-	700, 313, 667, 322, 5, 186, 532, 632, 368, 573,
-	405, 514, 522, 80, 223, 317, 150, 378, 9, 316,
-	132, 189, 8, 225, 228, 128, 143, 236, 237, 238,
-	239, 240, 147, 2, 241, 242, 243, 244, 245, 246,
-	247, 127, 250, 125, 513, 258, 259, 260, 315, 314,
-	137, 7, 6, 430, 264, 870, 864, 684, 854, 273,
-	274, 835, 276, 277, 214, 215, 590, 269, 230, 230,
-	82, 334, 309, 140, 141, 677, 759, 202, 203, 204,
-	205, 206, 207, 208, 209, 210, 211, 212, 213, 254,
-	406, 111, 105, 842, 892, 841, 868, 105, 704, 832,
-	541, 335, 319, 115, 121, 893, 324, 325, 84, 677,
-	869, 44, 306, 833, 302, 336, 728, 626, 621, 285,
-	287, 201, 105, 566, 337, 338, 339, 340, 341, 342,
-	343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
-	353, 354, 355, 356, 357, 358, 359, 360, 361, 362,
-	295, 364, 366, 556, 370, 321, 266, 372, 411, 568,
-	117, 269, 105, 232, 232, 862, 229, 235, 333, 79,
-	308, 380, 388, 390, 391, 392, 393, 394, 395, 396,
-	397, 398, 399, 400, 401, 190, 331, 402, 138, 404,
-	117, 225, 105, 261, 144, 730, 230, 424, 329, 384,
-	332, 307, 415, 268, 290, 225, 292, 855, 301, 179,
-	780, 299, 330, 926, 305, 308, 693, 409, 689, 610,
-	138, 597, 302, 585, 407, 410, 371, 425, 179, 283,
-	134, 416, 138, 112, 363, 518, 431, 511, 888, 106,
-	230, 820, 523, 524, 106, 819, 525, 809, 801, 233,
-	266, 165, 168, 169, 529, 270, 519, 533, 784, 225,
-	134, 606, 600, 112, 603, 601, 607, 117, 403, 106,
-	165, 230, 163, 162, 773, 727, 284, 717, 698, 233,
-	551, 219, 164, 166, 167, 535, 914, 161, 828, 423,
-	306, 232, 696, 688, 369, 650, 638, 5, 628, 782,
-	418, 164, 166, 167, 598, 561, 863, 151, 589, 106,
-	560, 9, 429, 520, 291, 8, 720, 510, 669, 670,
-	687, 517, 661, 117, 648, 105, 286, 516, 538, 813,
-	812, 110, 571, 554, 550, 232, 564, 134, 413, 106,
-	112, 552, 420, 421, 7, 6, 544, 646, 414, 270,
-	647, 826, 570, 562, 580, 385, 581, 558, 577, 582,
-	583, 575, 383, 288, 579, 559, 232, 218, 420, 427,
-	421, 421, 420, 217, 109, 289, 275, 272, 588, 271,
-	249, 220, 225, 592, 216, 225, 184, 183, 182, 408,
-	136, 135, 543, 134, 546, 572, 112, 131, 113, 609,
-	155, 157, 156, 179, 612, 930, 602, 929, 920, 668,
-	751, 595, 233, 387, 188, 903, 902, 587, 887, 850,
-	821, 815, 808, 768, 769, 765, 591, 181, 178, 179,
-	752, 716, 432, 512, 714, 712, 294, 710, 293, 707,
-	555, 540, 611, 153, 154, 165, 168, 169, 170, 171,
-	172, 173, 175, 177, 537, 768, 769, 386, 813, 812,
-	374, 231, 328, 234, 180, 159, 163, 162, 327, 179,
-	326, 165, 106, 158, 296, 160, 164, 166, 167, 174,
-	176, 161, 844, 165, 807, 804, 802, 138, 616, 761,
-	117, 608, 163, 162, 178, 909, 886, 859, 857, 803,
-	144, 536, 164, 166, 167, 627, 536, 161, 536, 790,
-	783, 165, 168, 169, 170, 171, 172, 173, 175, 177,
-	733, 620, 613, 536, 676, 642, 324, 644, 637, 617,
-	576, 625, 163, 162, 649, 306, 814, 634, 619, 185,
-	5, 179, 164, 166, 167, 174, 176, 161, 419, 120,
-	673, 179, 674, 671, 9, 640, 579, 789, 8, 643,
-	906, 685, 253, 114, 191, 196, 197, 615, 767, 114,
-	658, 198, 200, 199, 117, 651, 289, 718, 691, 515,
-	230, 230, 672, 165, 168, 169, 681, 7, 6, 263,
-	175, 177, 523, 165, 304, 255, 262, 533, 304, 574,
-	422, 123, 379, 124, 163, 162, 382, 230, 304, 117,
-	117, 77, 78, 708, 164, 166, 167, 174, 176, 161,
-	701, 904, 786, 715, 116, 705, 634, 225, 117, 695,
-	671, 722, 703, 699, 697, 702, 726, 546, 46, 546,
-	636, 304, 630, 671, 706, 304, 713, 122, 289, 732,
-	671, 146, 631, 721, 753, 754, 117, 547, 225, 749,
-	256, 257, 549, 690, 748, 255, 280, 281, 230, 298,
-	422, 731, 757, 724, 725, 232, 232, 192, 369, 653,
-	750, 324, 545, 300, 755, 614, 255, 738, 408, 618,
-	740, 225, 701, 905, 634, 542, 762, 320, 134, 303,
-	758, 112, 232, 760, 255, 686, 763, 669, 670, 777,
-	671, 770, 894, 772, 766, 148, 797, 779, 798, 775,
-	579, 791, 546, 800, 787, 528, 134, 546, 546, 112,
-	256, 257, 230, 745, 746, 747, 744, 743, 742, 810,
-	146, 745, 746, 747, 744, 743, 742, 794, 818, 805,
-	526, 256, 257, 829, 796, 824, 795, 148, 827, 117,
-	806, 117, 817, 232, 823, 604, 719, 129, 255, 256,
-	257, 834, 117, 422, 105, 816, 768, 769, 830, 635,
-	110, 548, 1, 849, 255, 536, 123, 883, 124, 282,
-	851, 843, 119, 377, 546, 375, 546, 848, 255, 195,
-	255, 194, 193, 278, 853, 252, 867, 187, 671, 38,
-	739, 846, 858, 871, 736, 737, 880, 866, 839, 884,
-	885, 775, 655, 109, 879, 663, 531, 232, 222, 890,
-	778, 891, 527, 256, 257, 895, 521, 889, 771, 768,
-	769, 898, 134, 860, 896, 112, 367, 880, 899, 256,
-	257, 546, 897, 873, 901, 879, 145, 792, 908, 142,
-	323, 233, 279, 256, 257, 256, 257, 149, 836, 912,
-	660, 822, 251, 381, 639, 913, 845, 928, 645, 840,
-	919, 922, 915, 224, 918, 917, 579, 43, 42, 923,
-	16, 15, 924, 599, 267, 49, 671, 48, 108, 927,
-	50, 4, 931, 88, 89, 70, 47, 93, 94, 36,
-	231, 105, 656, 27, 83, 654, 81, 110, 26, 18,
-	17, 106, 19, 72, 30, 248, 31, 62, 265, 20,
-	61, 878, 877, 21, 22, 35, 37, 876, 13, 23,
-	33, 875, 735, 34, 12, 45, 24, 665, 29, 86,
-	87, 10, 39, 40, 41, 723, 657, 310, 118, 51,
-	109, 297, 102, 98, 99, 100, 95, 96, 738, 3,
-	435, 740, 788, 729, 103, 0, 0, 0, 0, 11,
-	101, 97, 112, 0, 90, 91, 92, 0, 0, 0,
-	0, 85, 53, 0, 0, 0, 74, 75, 25, 77,
-	78, 0, 0, 0, 54, 55, 76, 63, 64, 65,
-	66, 67, 68, 69, 0, 0, 0, 0, 0, 0,
-	0, 0, 745, 746, 747, 744, 743, 742, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 104, 73, 14, 629, 32, 0, 60, 0, 52,
-	0, 0, 0, 57, 56, 58, 59, 71, 106, 4,
-	0, 88, 89, 70, 47, 93, 94, 36, 865, 105,
-	0, 27, 0, 0, 0, 110, 26, 18, 17, 0,
+	28, 132, 763, 629, 844, 867, 879, 583, 746, 440,
+	783, 109, 843, 820, 799, 680, 191, 633, 113, 666,
+	326, 128, 140, 140, 140, 648, 647, 153, 570, 710,
+	117, 123, 538, 81, 224, 188, 379, 721, 631, 527,
+	371, 634, 381, 578, 317, 321, 226, 5, 9, 149,
+	409, 152, 320, 228, 231, 8, 85, 239, 240, 241,
+	242, 243, 130, 134, 244, 245, 246, 247, 248, 249,
+	250, 319, 253, 145, 7, 261, 262, 263, 139, 318,
+	257, 44, 6, 127, 518, 519, 434, 129, 233, 233,
+	276, 277, 875, 279, 280, 83, 267, 861, 272, 851,
+	2, 142, 143, 689, 848, 841, 847, 595, 410, 337,
+	107, 235, 235, 313, 898, 873, 80, 838, 547, 573,
+	682, 682, 107, 286, 769, 899, 714, 704, 338, 874,
+	312, 839, 306, 294, 323, 296, 232, 238, 328, 329,
+	303, 146, 339, 309, 641, 626, 310, 571, 107, 562,
+	415, 868, 325, 192, 706, 181, 340, 341, 342, 343,
+	344, 345, 346, 347, 348, 349, 350, 351, 352, 353,
+	354, 355, 356, 357, 358, 359, 360, 361, 362, 363,
+	364, 365, 269, 367, 369, 335, 373, 333, 311, 375,
+	852, 789, 918, 272, 698, 289, 291, 167, 694, 336,
+	615, 334, 312, 273, 391, 393, 394, 395, 396, 397,
+	398, 399, 400, 401, 402, 403, 404, 405, 233, 299,
+	406, 140, 408, 305, 228, 288, 611, 602, 166, 168,
+	169, 612, 119, 383, 107, 419, 264, 306, 228, 590,
+	112, 235, 411, 414, 387, 929, 862, 764, 894, 428,
+	828, 827, 818, 140, 287, 181, 807, 108, 413, 835,
+	429, 793, 119, 233, 107, 140, 372, 736, 523, 108,
+	435, 516, 420, 726, 374, 528, 529, 269, 366, 530,
+	708, 222, 605, 111, 608, 606, 235, 703, 535, 524,
+	701, 539, 869, 228, 233, 108, 693, 167, 273, 407,
+	664, 653, 136, 643, 603, 114, 594, 119, 295, 107,
+	791, 417, 822, 821, 557, 112, 729, 235, 165, 164,
+	692, 236, 675, 549, 290, 552, 310, 541, 166, 168,
+	169, 422, 136, 163, 576, 114, 424, 425, 566, 412,
+	153, 427, 431, 433, 5, 9, 661, 560, 558, 662,
+	756, 236, 8, 515, 522, 534, 525, 669, 111, 418,
+	521, 181, 424, 388, 425, 425, 424, 221, 386, 569,
+	234, 7, 237, 220, 292, 556, 278, 136, 275, 6,
+	114, 108, 436, 517, 274, 293, 565, 585, 252, 586,
+	550, 567, 587, 588, 580, 223, 236, 584, 219, 544,
+	816, 186, 185, 167, 170, 171, 184, 138, 564, 137,
+	133, 108, 593, 115, 119, 575, 228, 597, 933, 228,
+	932, 582, 390, 577, 165, 164, 607, 157, 159, 158,
+	181, 778, 779, 614, 166, 168, 169, 190, 617, 163,
+	778, 779, 924, 119, 908, 234, 298, 670, 297, 907,
+	668, 146, 893, 600, 183, 180, 108, 858, 829, 824,
+	817, 775, 596, 757, 725, 636, 637, 724, 722, 720,
+	155, 156, 167, 170, 171, 172, 173, 174, 175, 177,
+	179, 717, 561, 546, 136, 822, 821, 114, 543, 389,
+	377, 182, 161, 165, 164, 592, 332, 331, 330, 300,
+	160, 813, 162, 166, 168, 169, 176, 178, 163, 808,
+	771, 613, 542, 258, 217, 218, 116, 542, 426, 913,
+	616, 865, 140, 621, 864, 542, 542, 204, 205, 206,
+	207, 208, 209, 210, 211, 212, 213, 214, 215, 216,
+	809, 642, 796, 423, 823, 792, 638, 738, 167, 119,
+	681, 107, 767, 777, 581, 625, 635, 187, 116, 77,
+	181, 657, 328, 659, 122, 293, 640, 911, 624, 663,
+	552, 203, 552, 310, 622, 649, 256, 118, 259, 260,
+	676, 308, 658, 193, 520, 148, 850, 679, 638, 5,
+	9, 584, 271, 266, 652, 308, 690, 8, 198, 199,
+	620, 618, 167, 308, 655, 233, 233, 200, 202, 201,
+	119, 308, 665, 696, 265, 678, 7, 727, 672, 136,
+	579, 677, 114, 119, 6, 382, 119, 528, 235, 235,
+	78, 79, 233, 385, 686, 293, 909, 619, 236, 795,
+	412, 623, 539, 533, 910, 119, 712, 638, 324, 646,
+	125, 651, 126, 372, 667, 235, 695, 555, 718, 645,
+	553, 733, 734, 308, 552, 548, 702, 711, 700, 552,
+	552, 228, 715, 649, 709, 731, 713, 707, 716, 735,
+	691, 283, 284, 551, 135, 106, 302, 638, 900, 758,
+	759, 650, 800, 228, 754, 119, 124, 753, 108, 304,
+	723, 148, 233, 258, 121, 730, 750, 751, 752, 749,
+	748, 747, 258, 812, 737, 136, 638, 307, 114, 119,
+	150, 328, 125, 150, 126, 235, 46, 760, 755, 609,
+	228, 552, 131, 552, 711, 554, 649, 762, 542, 768,
+	772, 776, 770, 765, 802, 773, 801, 786, 135, 106,
+	728, 803, 258, 804, 797, 584, 380, 426, 806, 119,
+	780, 233, 782, 378, 788, 194, 197, 531, 259, 260,
+	258, 784, 825, 778, 779, 281, 638, 259, 260, 819,
+	196, 195, 811, 1, 235, 189, 38, 826, 552, 743,
+	744, 814, 745, 741, 832, 742, 833, 834, 630, 815,
+	810, 537, 225, 831, 781, 778, 779, 526, 866, 787,
+	636, 637, 836, 370, 878, 147, 532, 259, 260, 845,
+	798, 144, 857, 743, 327, 849, 745, 151, 842, 136,
+	674, 830, 114, 856, 282, 259, 260, 840, 860, 254,
+	794, 384, 872, 750, 751, 752, 749, 748, 747, 654,
+	876, 889, 890, 885, 871, 853, 931, 891, 892, 258,
+	884, 660, 846, 854, 426, 227, 896, 897, 258, 43,
+	42, 16, 784, 285, 895, 15, 903, 750, 751, 752,
+	749, 748, 747, 885, 604, 906, 270, 902, 258, 888,
+	884, 49, 48, 255, 110, 50, 84, 82, 72, 251,
+	62, 268, 61, 883, 882, 916, 881, 880, 740, 901,
+	45, 632, 732, 904, 671, 925, 923, 919, 314, 922,
+	921, 584, 926, 870, 259, 260, 120, 927, 301, 3,
+	638, 439, 930, 259, 260, 934, 766, 705, 0, 4,
+	917, 89, 90, 70, 47, 94, 95, 36, 0, 107,
+	0, 27, 0, 259, 260, 112, 26, 18, 17, 0,
 	19, 0, 30, 0, 31, 0, 0, 20, 0, 0,
-	0, 21, 22, 35, 37, 0, 13, 23, 33, 0,
-	0, 34, 12, 0, 24, 0, 29, 86, 87, 10,
-	39, 40, 41, 0, 0, 0, 0, 51, 109, 0,
-	102, 98, 99, 100, 95, 96, 738, 0, 0, 740,
-	0, 0, 103, 0, 0, 0, 0, 11, 101, 97,
-	112, 0, 90, 91, 92, 0, 0, 0, 0, 85,
-	53, 0, 0, 0, 74, 75, 25, 77, 78, 0,
+	0, 21, 22, 35, 37, 106, 13, 23, 33, 0,
+	0, 34, 12, 0, 24, 0, 29, 87, 88, 10,
+	39, 40, 41, 0, 0, 0, 0, 51, 111, 0,
+	103, 99, 100, 101, 96, 97, 743, 0, 0, 745,
+	0, 0, 104, 0, 0, 0, 0, 11, 102, 98,
+	114, 0, 91, 92, 93, 0, 0, 0, 0, 86,
+	53, 0, 0, 0, 74, 75, 25, 78, 79, 0,
 	0, 0, 54, 55, 76, 63, 64, 65, 66, 67,
 	68, 69, 0, 0, 0, 0, 0, 0, 0, 0,
-	745, 746, 747, 744, 743, 742, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 104,
-	73, 14, 539, 32, 0, 60, 0, 52, 0, 0,
-	0, 57, 56, 58, 59, 71, 106, 4, 0, 88,
-	89, 70, 47, 93, 94, 36, 831, 105, 0, 27,
-	0, 0, 0, 110, 26, 18, 17, 0, 19, 0,
+	750, 751, 752, 749, 748, 747, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 105,
+	73, 14, 644, 32, 0, 60, 0, 52, 0, 0,
+	0, 57, 56, 58, 59, 71, 108, 4, 0, 89,
+	90, 70, 47, 94, 95, 36, 837, 107, 0, 27,
+	0, 0, 0, 112, 26, 18, 17, 0, 19, 0,
 	30, 0, 31, 0, 0, 20, 0, 0, 0, 21,
-	22, 35, 37, 0, 13, 23, 33, 0, 0, 34,
-	12, 0, 24, 0, 29, 86, 87, 10, 39, 40,
-	41, 0, 0, 0, 0, 51, 109, 0, 102, 98,
-	99, 100, 95, 96, 738, 0, 0, 740, 0, 0,
-	103, 0, 0, 0, 0, 11, 101, 97, 112, 0,
-	90, 91, 92, 0, 0, 0, 0, 85, 53, 0,
-	0, 0, 74, 75, 25, 77, 78, 0, 0, 0,
+	22, 35, 37, 106, 13, 23, 33, 0, 0, 34,
+	12, 0, 24, 0, 29, 87, 88, 10, 39, 40,
+	41, 0, 0, 0, 0, 51, 111, 0, 103, 99,
+	100, 101, 96, 97, 743, 0, 0, 745, 0, 0,
+	104, 0, 0, 0, 0, 11, 102, 98, 114, 0,
+	91, 92, 93, 0, 0, 0, 0, 86, 53, 0,
+	0, 0, 74, 75, 25, 78, 79, 0, 0, 0,
 	54, 55, 76, 63, 64, 65, 66, 67, 68, 69,
-	0, 0, 0, 0, 0, 0, 0, 0, 745, 746,
-	747, 744, 743, 742, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 104, 73, 14,
-	0, 32, 0, 60, 0, 52, 0, 0, 0, 57,
-	56, 58, 59, 71, 106, 312, 0, 88, 89, 70,
-	47, 93, 94, 36, 799, 105, 0, 27, 0, 0,
-	0, 110, 26, 18, 17, 0, 19, 0, 30, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 750, 751,
+	752, 749, 748, 747, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 105, 73, 14,
+	545, 32, 0, 60, 0, 52, 0, 0, 0, 57,
+	56, 58, 59, 71, 108, 4, 0, 89, 90, 70,
+	47, 94, 95, 36, 805, 107, 0, 27, 0, 0,
+	0, 112, 26, 18, 17, 0, 19, 0, 30, 0,
 	31, 0, 0, 20, 0, 0, 0, 21, 22, 35,
-	37, 0, 0, 23, 33, 0, 0, 34, 0, 0,
-	24, 0, 29, 86, 87, 318, 39, 40, 41, 0,
-	0, 0, 0, 51, 109, 0, 102, 98, 99, 100,
-	95, 96, 738, 0, 0, 740, 0, 0, 103, 0,
-	0, 0, 0, 134, 101, 97, 112, 0, 90, 91,
-	92, 0, 0, 0, 0, 85, 53, 0, 0, 0,
-	74, 75, 25, 77, 78, 0, 0, 0, 54, 55,
+	37, 106, 13, 23, 33, 0, 0, 34, 12, 0,
+	24, 0, 29, 87, 88, 10, 39, 40, 41, 0,
+	0, 0, 0, 51, 111, 0, 103, 99, 100, 101,
+	96, 97, 743, 0, 0, 745, 0, 0, 104, 0,
+	0, 0, 0, 11, 102, 98, 114, 0, 91, 92,
+	93, 0, 0, 0, 0, 86, 53, 0, 0, 0,
+	74, 75, 25, 78, 79, 0, 0, 0, 54, 55,
 	76, 63, 64, 65, 66, 67, 68, 69, 0, 0,
-	0, 0, 0, 0, 0, 0, 745, 746, 747, 744,
-	743, 742, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 104, 73, 14, 932, 32,
+	0, 0, 0, 0, 0, 0, 750, 751, 752, 749,
+	748, 747, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 105, 73, 14, 0, 32,
 	0, 60, 0, 52, 0, 0, 0, 57, 56, 58,
-	59, 71, 106, 312, 0, 88, 89, 70, 47, 93,
-	94, 36, 734, 105, 0, 27, 0, 0, 0, 110,
+	59, 71, 108, 316, 0, 89, 90, 70, 47, 94,
+	95, 36, 739, 107, 0, 27, 0, 0, 0, 112,
 	26, 18, 17, 0, 19, 0, 30, 0, 31, 0,
-	0, 20, 0, 0, 0, 21, 22, 35, 37, 0,
+	0, 20, 0, 0, 0, 21, 22, 35, 37, 106,
 	0, 23, 33, 0, 0, 34, 0, 0, 24, 0,
-	29, 86, 87, 318, 39, 40, 41, 0, 0, 0,
-	0, 51, 109, 0, 102, 98, 99, 100, 95, 96,
-	0, 0, 0, 0, 0, 0, 103, 0, 0, 0,
-	0, 134, 101, 97, 112, 0, 90, 91, 92, 0,
-	0, 0, 0, 85, 53, 0, 0, 0, 74, 75,
-	25, 77, 78, 0, 0, 0, 54, 55, 76, 63,
+	29, 87, 88, 322, 39, 40, 41, 0, 0, 0,
+	0, 51, 111, 0, 103, 99, 100, 101, 96, 97,
+	0, 0, 0, 0, 0, 0, 104, 0, 0, 0,
+	0, 136, 102, 98, 114, 0, 91, 92, 93, 0,
+	0, 0, 0, 86, 53, 0, 0, 0, 74, 75,
+	25, 78, 79, 0, 0, 0, 54, 55, 76, 63,
 	64, 65, 66, 67, 68, 69, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 104, 73, 14, 925, 32, 0, 60,
+	0, 0, 0, 105, 73, 14, 935, 32, 0, 60,
 	0, 52, 0, 0, 0, 57, 56, 58, 59, 71,
-	106, 312, 0, 88, 89, 70, 47, 93, 94, 36,
-	0, 105, 0, 27, 0, 0, 0, 110, 26, 18,
+	108, 316, 0, 89, 90, 70, 47, 94, 95, 36,
+	0, 107, 0, 27, 0, 0, 0, 112, 26, 18,
 	17, 0, 19, 0, 30, 0, 31, 0, 0, 20,
-	0, 0, 0, 21, 22, 35, 37, 0, 0, 23,
-	33, 0, 0, 34, 0, 0, 24, 0, 29, 86,
-	87, 318, 39, 40, 41, 0, 0, 0, 0, 51,
-	109, 0, 102, 98, 99, 100, 95, 96, 0, 0,
-	0, 0, 0, 0, 103, 0, 0, 0, 0, 134,
-	101, 97, 112, 0, 90, 91, 92, 0, 0, 0,
-	0, 85, 53, 0, 0, 0, 74, 75, 25, 77,
-	78, 0, 0, 0, 54, 55, 76, 63, 64, 65,
+	0, 0, 0, 21, 22, 35, 37, 106, 0, 23,
+	33, 0, 0, 34, 0, 0, 24, 0, 29, 87,
+	88, 322, 39, 40, 41, 0, 0, 0, 0, 51,
+	111, 0, 103, 99, 100, 101, 96, 97, 0, 0,
+	0, 0, 0, 0, 104, 0, 0, 0, 0, 136,
+	102, 98, 114, 0, 91, 92, 93, 0, 0, 0,
+	0, 86, 53, 0, 0, 0, 74, 75, 25, 78,
+	79, 0, 0, 0, 54, 55, 76, 63, 64, 65,
 	66, 67, 68, 69, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 104, 73, 14, 921, 32, 0, 60, 0, 52,
-	0, 0, 0, 57, 56, 58, 59, 71, 106, 312,
-	0, 88, 89, 70, 47, 93, 94, 36, 0, 105,
-	0, 27, 0, 0, 0, 110, 26, 18, 17, 0,
+	0, 105, 73, 14, 928, 32, 0, 60, 0, 52,
+	0, 0, 0, 57, 56, 58, 59, 71, 108, 316,
+	0, 89, 90, 70, 47, 94, 95, 36, 0, 107,
+	0, 27, 0, 0, 0, 112, 26, 18, 17, 0,
 	19, 0, 30, 0, 31, 0, 0, 20, 0, 0,
-	0, 21, 22, 35, 37, 0, 0, 23, 33, 0,
-	0, 34, 0, 0, 24, 0, 29, 86, 87, 318,
-	39, 40, 41, 0, 0, 0, 0, 51, 109, 0,
-	102, 98, 99, 100, 95, 96, 0, 0, 0, 0,
-	0, 0, 103, 0, 0, 0, 0, 134, 101, 97,
-	112, 0, 90, 91, 92, 0, 0, 0, 0, 85,
-	53, 0, 0, 0, 74, 75, 25, 77, 78, 0,
+	0, 21, 22, 35, 37, 106, 0, 23, 33, 0,
+	0, 34, 0, 0, 24, 0, 29, 87, 88, 322,
+	39, 40, 41, 0, 0, 0, 0, 51, 111, 0,
+	103, 99, 100, 101, 96, 97, 0, 0, 0, 0,
+	0, 0, 104, 0, 0, 0, 0, 136, 102, 98,
+	114, 0, 91, 92, 93, 0, 0, 0, 0, 86,
+	53, 0, 0, 0, 74, 75, 25, 78, 79, 0,
 	0, 0, 54, 55, 76, 63, 64, 65, 66, 67,
 	68, 69, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 104,
-	73, 14, 911, 32, 0, 60, 0, 52, 0, 0,
-	0, 57, 56, 58, 59, 71, 106, 312, 0, 88,
-	89, 70, 47, 93, 94, 36, 0, 105, 0, 27,
-	0, 0, 0, 110, 26, 18, 17, 0, 19, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 105,
+	73, 14, 915, 32, 0, 60, 0, 52, 0, 0,
+	0, 57, 56, 58, 59, 71, 108, 316, 0, 89,
+	90, 70, 47, 94, 95, 36, 0, 107, 0, 27,
+	0, 0, 0, 112, 26, 18, 17, 0, 19, 0,
 	30, 0, 31, 0, 0, 20, 0, 0, 0, 21,
-	22, 35, 37, 0, 0, 23, 33, 0, 0, 34,
-	0, 0, 24, 0, 29, 86, 87, 318, 39, 40,
-	41, 0, 0, 0, 0, 51, 109, 0, 102, 98,
-	99, 100, 95, 96, 0, 0, 0, 0, 0, 0,
-	103, 0, 0, 0, 0, 134, 101, 97, 112, 0,
-	90, 91, 92, 0, 0, 0, 0, 85, 53, 0,
-	0, 0, 74, 75, 25, 77, 78, 0, 0, 0,
+	22, 35, 37, 106, 0, 23, 33, 0, 0, 34,
+	0, 0, 24, 0, 29, 87, 88, 322, 39, 40,
+	41, 0, 0, 0, 0, 51, 111, 0, 103, 99,
+	100, 101, 96, 97, 0, 0, 0, 0, 0, 0,
+	104, 0, 0, 0, 0, 136, 102, 98, 114, 0,
+	91, 92, 93, 0, 0, 0, 0, 86, 53, 0,
+	0, 0, 74, 75, 25, 78, 79, 0, 0, 0,
 	54, 55, 76, 63, 64, 65, 66, 67, 68, 69,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 104, 73, 14,
-	910, 32, 0, 60, 0, 52, 0, 0, 0, 57,
-	56, 58, 59, 71, 106, 312, 0, 88, 89, 70,
-	47, 93, 94, 36, 0, 105, 0, 27, 0, 0,
-	0, 110, 26, 18, 17, 0, 19, 907, 30, 0,
+	0, 0, 0, 0, 0, 0, 0, 105, 73, 14,
+	914, 32, 0, 60, 0, 52, 0, 0, 0, 57,
+	56, 58, 59, 71, 108, 316, 0, 89, 90, 70,
+	47, 94, 95, 36, 0, 107, 0, 27, 0, 0,
+	0, 112, 26, 18, 17, 0, 19, 912, 30, 0,
 	31, 0, 0, 20, 0, 0, 0, 21, 22, 35,
-	37, 0, 0, 23, 33, 0, 0, 34, 0, 0,
-	24, 0, 29, 86, 87, 318, 39, 40, 41, 0,
-	0, 0, 0, 51, 109, 0, 102, 98, 99, 100,
-	95, 96, 0, 0, 0, 0, 0, 0, 103, 0,
-	0, 0, 0, 134, 101, 97, 112, 0, 90, 91,
-	92, 0, 0, 0, 0, 85, 53, 0, 0, 0,
-	74, 75, 25, 77, 78, 0, 0, 0, 54, 55,
+	37, 106, 0, 23, 33, 0, 0, 34, 0, 0,
+	24, 0, 29, 87, 88, 322, 39, 40, 41, 0,
+	0, 0, 0, 51, 111, 0, 103, 99, 100, 101,
+	96, 97, 0, 0, 0, 0, 0, 0, 104, 0,
+	0, 0, 0, 136, 102, 98, 114, 0, 91, 92,
+	93, 0, 0, 0, 0, 86, 53, 0, 0, 0,
+	74, 75, 25, 78, 79, 0, 0, 0, 54, 55,
 	76, 63, 64, 65, 66, 67, 68, 69, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 104, 73, 14, 0, 32,
+	0, 0, 0, 0, 0, 105, 73, 14, 0, 32,
 	0, 60, 0, 52, 0, 0, 0, 57, 56, 58,
-	59, 71, 106, 312, 0, 88, 89, 70, 47, 93,
-	94, 36, 0, 105, 0, 27, 0, 0, 0, 110,
+	59, 71, 108, 316, 0, 89, 90, 70, 47, 94,
+	95, 36, 0, 107, 0, 27, 0, 0, 0, 112,
 	26, 18, 17, 0, 19, 0, 30, 0, 31, 0,
-	0, 20, 0, 0, 0, 21, 22, 35, 37, 0,
+	0, 20, 0, 0, 0, 21, 22, 35, 37, 106,
 	0, 23, 33, 0, 0, 34, 0, 0, 24, 0,
-	29, 86, 87, 318, 39, 40, 41, 0, 0, 0,
-	0, 51, 109, 0, 102, 98, 99, 100, 95, 96,
-	0, 0, 0, 0, 0, 0, 103, 0, 0, 0,
-	0, 134, 101, 97, 112, 0, 90, 91, 92, 0,
-	0, 0, 0, 85, 53, 0, 0, 0, 74, 75,
-	25, 77, 78, 0, 0, 0, 54, 55, 76, 63,
+	29, 87, 88, 322, 39, 40, 41, 0, 0, 0,
+	0, 51, 111, 0, 103, 99, 100, 101, 96, 97,
+	0, 0, 0, 0, 0, 0, 104, 0, 0, 0,
+	0, 136, 102, 98, 114, 0, 91, 92, 93, 0,
+	0, 0, 0, 86, 53, 0, 0, 0, 74, 75,
+	25, 78, 79, 0, 0, 0, 54, 55, 76, 63,
 	64, 65, 66, 67, 68, 69, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 104, 73, 14, 856, 32, 0, 60,
+	0, 0, 0, 105, 73, 14, 863, 32, 0, 60,
 	0, 52, 0, 0, 0, 57, 56, 58, 59, 71,
-	106, 312, 0, 88, 89, 70, 47, 93, 94, 36,
-	0, 105, 0, 27, 0, 0, 0, 110, 26, 18,
-	17, 0, 19, 0, 30, 852, 31, 0, 0, 20,
-	0, 0, 0, 21, 22, 35, 37, 0, 0, 23,
-	33, 0, 0, 34, 0, 0, 24, 0, 29, 86,
-	87, 318, 39, 40, 41, 0, 0, 0, 0, 51,
-	109, 0, 102, 98, 99, 100, 95, 96, 0, 0,
-	0, 0, 0, 0, 103, 0, 0, 0, 0, 134,
-	101, 97, 112, 0, 90, 91, 92, 0, 0, 0,
-	0, 85, 53, 0, 0, 0, 74, 75, 25, 77,
-	78, 0, 0, 0, 54, 55, 76, 63, 64, 65,
+	108, 316, 0, 89, 90, 70, 47, 94, 95, 36,
+	0, 107, 0, 27, 0, 0, 0, 112, 26, 18,
+	17, 0, 19, 0, 30, 859, 31, 0, 0, 20,
+	0, 0, 0, 21, 22, 35, 37, 106, 0, 23,
+	33, 0, 0, 34, 0, 0, 24, 0, 29, 87,
+	88, 322, 39, 40, 41, 0, 0, 0, 0, 51,
+	111, 0, 103, 99, 100, 101, 96, 97, 0, 0,
+	0, 0, 0, 0, 104, 0, 0, 0, 0, 136,
+	102, 98, 114, 0, 91, 92, 93, 0, 0, 0,
+	0, 86, 53, 0, 0, 0, 74, 75, 25, 78,
+	79, 0, 0, 0, 54, 55, 76, 63, 64, 65,
 	66, 67, 68, 69, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 104, 73, 14, 0, 32, 0, 60, 0, 52,
-	0, 0, 0, 57, 56, 58, 59, 71, 106, 312,
-	0, 88, 89, 70, 47, 93, 94, 36, 0, 105,
-	0, 27, 0, 0, 0, 110, 26, 18, 17, 0,
-	19, 0, 30, 0, 31, 781, 0, 20, 0, 0,
-	0, 21, 22, 35, 37, 0, 0, 23, 33, 0,
-	0, 34, 0, 0, 24, 0, 29, 86, 87, 318,
-	39, 40, 41, 0, 0, 0, 0, 51, 109, 0,
-	102, 98, 99, 100, 95, 96, 0, 0, 0, 0,
-	0, 0, 103, 0, 0, 0, 0, 134, 101, 97,
-	112, 0, 90, 91, 92, 0, 0, 0, 0, 85,
-	53, 0, 0, 0, 74, 75, 25, 77, 78, 0,
+	0, 105, 73, 14, 0, 32, 0, 60, 0, 52,
+	0, 0, 0, 57, 56, 58, 59, 71, 108, 316,
+	0, 89, 90, 70, 47, 94, 95, 36, 0, 107,
+	0, 27, 0, 0, 0, 112, 26, 18, 17, 0,
+	19, 0, 30, 0, 31, 790, 0, 20, 0, 0,
+	0, 21, 22, 35, 37, 106, 0, 23, 33, 0,
+	0, 34, 0, 0, 24, 0, 29, 87, 88, 322,
+	39, 40, 41, 0, 0, 0, 0, 51, 111, 0,
+	103, 99, 100, 101, 96, 97, 0, 0, 0, 0,
+	0, 0, 104, 0, 0, 0, 0, 136, 102, 98,
+	114, 0, 91, 92, 93, 0, 0, 0, 0, 86,
+	53, 0, 0, 0, 74, 75, 25, 78, 79, 0,
 	0, 0, 54, 55, 76, 63, 64, 65, 66, 67,
 	68, 69, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 104,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 105,
 	73, 14, 0, 32, 0, 60, 0, 52, 0, 0,
-	0, 57, 56, 58, 59, 71, 106, 312, 0, 88,
-	89, 70, 47, 93, 94, 36, 0, 105, 0, 27,
-	0, 0, 0, 110, 26, 18, 17, 764, 19, 0,
+	0, 57, 56, 58, 59, 71, 108, 316, 0, 89,
+	90, 70, 47, 94, 95, 36, 0, 107, 0, 27,
+	0, 0, 0, 112, 26, 18, 17, 774, 19, 0,
 	30, 0, 31, 0, 0, 20, 0, 0, 0, 21,
-	22, 35, 37, 0, 0, 23, 33, 0, 0, 34,
-	0, 0, 24, 0, 29, 86, 87, 318, 39, 40,
-	41, 0, 0, 0, 0, 51, 109, 0, 102, 98,
-	99, 100, 95, 96, 0, 0, 0, 0, 0, 0,
-	103, 0, 0, 0, 0, 134, 101, 97, 112, 0,
-	90, 91, 92, 0, 0, 0, 0, 85, 53, 0,
-	0, 0, 74, 75, 25, 77, 78, 0, 0, 0,
+	22, 35, 37, 106, 0, 23, 33, 0, 0, 34,
+	0, 0, 24, 0, 29, 87, 88, 322, 39, 40,
+	41, 0, 0, 0, 0, 51, 111, 0, 103, 99,
+	100, 101, 96, 97, 0, 0, 0, 0, 0, 0,
+	104, 0, 0, 0, 0, 136, 102, 98, 114, 0,
+	91, 92, 93, 0, 0, 0, 0, 86, 53, 0,
+	0, 0, 74, 75, 25, 78, 79, 0, 0, 0,
 	54, 55, 76, 63, 64, 65, 66, 67, 68, 69,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 104, 73, 14,
+	0, 0, 0, 0, 0, 0, 0, 105, 73, 14,
 	0, 32, 0, 60, 0, 52, 0, 0, 0, 57,
-	56, 58, 59, 71, 106, 312, 0, 88, 89, 70,
-	47, 93, 94, 36, 0, 105, 0, 27, 0, 0,
-	0, 110, 26, 18, 17, 0, 19, 0, 30, 0,
+	56, 58, 59, 71, 108, 316, 0, 89, 90, 70,
+	47, 94, 95, 36, 0, 107, 0, 27, 0, 0,
+	0, 112, 26, 18, 17, 0, 19, 0, 30, 0,
 	31, 0, 0, 20, 0, 0, 0, 21, 22, 35,
-	37, 0, 0, 23, 33, 0, 0, 34, 0, 0,
-	24, 0, 29, 86, 87, 318, 39, 40, 41, 0,
-	0, 0, 0, 51, 109, 0, 102, 98, 99, 100,
-	95, 96, 0, 0, 0, 0, 0, 0, 103, 0,
-	0, 0, 0, 134, 101, 97, 112, 0, 90, 91,
-	92, 0, 0, 0, 0, 85, 53, 0, 0, 680,
-	74, 75, 25, 77, 78, 0, 0, 0, 54, 55,
+	37, 106, 0, 23, 33, 0, 0, 34, 0, 0,
+	24, 0, 29, 87, 88, 322, 39, 40, 41, 0,
+	0, 0, 0, 51, 111, 0, 103, 99, 100, 101,
+	96, 97, 0, 0, 0, 0, 0, 0, 104, 0,
+	0, 0, 0, 136, 102, 98, 114, 0, 91, 92,
+	93, 0, 0, 0, 0, 86, 53, 0, 0, 685,
+	74, 75, 25, 78, 79, 0, 0, 0, 54, 55,
 	76, 63, 64, 65, 66, 67, 68, 69, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 104, 73, 14, 0, 32,
+	0, 0, 0, 0, 0, 105, 73, 14, 0, 32,
 	0, 60, 0, 52, 0, 0, 0, 57, 56, 58,
-	59, 71, 106, 312, 0, 88, 89, 70, 47, 93,
-	94, 36, 0, 105, 0, 27, 0, 0, 0, 110,
+	59, 71, 108, 316, 0, 89, 90, 70, 47, 94,
+	95, 36, 0, 107, 0, 27, 0, 0, 0, 112,
 	26, 18, 17, 0, 19, 0, 30, 0, 31, 0,
-	0, 20, 0, 0, 0, 21, 22, 35, 37, 0,
+	0, 20, 0, 0, 0, 21, 22, 35, 37, 106,
 	0, 23, 33, 0, 0, 34, 0, 0, 24, 0,
-	29, 86, 87, 318, 39, 40, 41, 0, 0, 0,
-	0, 51, 109, 0, 102, 98, 99, 100, 95, 96,
-	0, 0, 0, 0, 0, 0, 103, 0, 0, 0,
-	0, 134, 101, 97, 112, 0, 90, 91, 92, 0,
-	0, 0, 0, 85, 53, 0, 0, 0, 74, 75,
-	25, 77, 78, 0, 0, 0, 54, 55, 76, 63,
+	29, 87, 88, 322, 39, 40, 41, 0, 0, 0,
+	0, 51, 111, 0, 103, 99, 100, 101, 96, 97,
+	0, 0, 0, 0, 0, 0, 104, 0, 0, 0,
+	0, 136, 102, 98, 114, 0, 91, 92, 93, 0,
+	0, 0, 0, 86, 53, 0, 0, 0, 74, 75,
+	25, 78, 79, 0, 0, 0, 54, 55, 76, 63,
 	64, 65, 66, 67, 68, 69, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 104, 73, 14, 569, 32, 0, 60,
+	0, 0, 0, 105, 73, 14, 574, 32, 0, 60,
 	0, 52, 0, 0, 0, 57, 56, 58, 59, 71,
-	106, 312, 0, 88, 89, 70, 47, 93, 94, 36,
-	0, 105, 0, 27, 0, 0, 0, 110, 26, 18,
+	108, 316, 0, 89, 90, 70, 47, 94, 95, 36,
+	0, 107, 0, 27, 0, 0, 0, 112, 26, 18,
 	17, 0, 19, 0, 30, 0, 31, 0, 0, 20,
-	0, 0, 0, 21, 22, 35, 37, 0, 0, 23,
-	33, 0, 0, 34, 0, 0, 24, 0, 29, 86,
-	87, 318, 39, 40, 41, 0, 0, 0, 0, 51,
-	109, 0, 102, 98, 99, 100, 95, 96, 0, 0,
-	0, 0, 0, 0, 103, 0, 0, 0, 0, 134,
-	101, 97, 112, 0, 90, 91, 92, 0, 0, 0,
-	0, 85, 53, 0, 0, 0, 74, 75, 25, 77,
-	78, 0, 0, 0, 54, 55, 76, 63, 64, 65,
+	0, 0, 0, 21, 22, 35, 37, 106, 0, 23,
+	33, 0, 0, 34, 0, 0, 24, 0, 29, 87,
+	88, 322, 39, 40, 41, 0, 0, 0, 0, 51,
+	111, 0, 103, 99, 100, 101, 96, 97, 0, 0,
+	0, 0, 0, 0, 104, 0, 0, 0, 0, 136,
+	102, 98, 114, 0, 91, 92, 93, 0, 0, 0,
+	0, 86, 53, 0, 0, 0, 74, 75, 25, 78,
+	79, 0, 0, 0, 54, 55, 76, 63, 64, 65,
 	66, 67, 68, 69, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 104, 73, 14, 311, 32, 0, 60, 0, 52,
-	0, 0, 0, 57, 56, 58, 59, 71, 106, 312,
-	0, 88, 89, 70, 47, 93, 94, 36, 0, 105,
-	0, 27, 0, 0, 0, 110, 26, 18, 17, 0,
+	0, 105, 73, 14, 315, 32, 0, 60, 0, 52,
+	0, 0, 0, 57, 56, 58, 59, 71, 108, 316,
+	0, 89, 90, 70, 47, 94, 95, 36, 0, 107,
+	0, 27, 0, 0, 0, 112, 26, 18, 17, 0,
 	19, 0, 30, 0, 31, 0, 0, 20, 0, 0,
-	0, 21, 22, 35, 37, 0, 0, 23, 33, 0,
-	0, 34, 0, 0, 24, 0, 29, 86, 87, 318,
-	39, 40, 41, 0, 0, 0, 0, 51, 109, 0,
-	102, 98, 99, 100, 95, 96, 0, 0, 0, 0,
-	0, 0, 103, 0, 0, 0, 0, 134, 101, 97,
-	112, 0, 90, 91, 92, 0, 0, 0, 0, 85,
-	53, 0, 0, 0, 74, 75, 25, 77, 78, 0,
+	0, 21, 22, 35, 37, 106, 0, 23, 33, 0,
+	0, 34, 0, 0, 24, 0, 29, 87, 88, 322,
+	39, 40, 41, 0, 0, 0, 0, 51, 111, 0,
+	103, 99, 100, 101, 96, 97, 0, 0, 0, 0,
+	0, 0, 104, 0, 0, 0, 0, 136, 102, 98,
+	114, 0, 91, 92, 93, 0, 0, 0, 0, 86,
+	53, 0, 0, 0, 74, 75, 25, 78, 79, 0,
 	0, 0, 54, 55, 76, 63, 64, 65, 66, 67,
 	68, 69, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 104,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 105,
 	73, 14, 0, 32, 0, 60, 0, 52, 0, 0,
-	0, 57, 56, 58, 59, 71, 106, 443, 444, 454,
-	455, 0, 0, 434, 0, 105, 0, 0, 0, 0,
-	0, 0, 459, 460, 461, 462, 463, 464, 465, 466,
-	467, 468, 469, 489, 490, 491, 492, 493, 481, 482,
-	483, 0, 484, 485, 470, 471, 472, 473, 474, 475,
-	476, 477, 478, 479, 480, 0, 501, 499, 500, 496,
-	497, 0, 0, 488, 494, 495, 502, 503, 505, 504,
-	506, 507, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 498, 509, 508, 0, 0, 445, 446,
-	447, 448, 449, 450, 451, 452, 453, 456, 457, 458,
-	486, 487, 437, 438, 439, 440, 441, 442, 88, 89,
-	70, 47, 93, 94, 36, 0, 105, 0, 27, 0,
-	0, 0, 110, 26, 18, 17, 0, 19, 0, 30,
+	0, 57, 56, 58, 59, 71, 108, 447, 448, 458,
+	459, 0, 0, 438, 0, 107, 0, 0, 0, 0,
+	0, 0, 463, 464, 465, 466, 467, 468, 469, 470,
+	471, 472, 473, 493, 494, 495, 496, 497, 485, 486,
+	487, 514, 488, 489, 474, 475, 476, 477, 478, 479,
+	480, 481, 482, 483, 484, 0, 505, 503, 504, 500,
+	501, 0, 0, 492, 498, 499, 506, 507, 509, 508,
+	510, 511, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 502, 513, 512, 0, 0, 449, 450,
+	451, 452, 453, 454, 455, 456, 457, 460, 461, 462,
+	490, 491, 441, 442, 443, 444, 445, 446, 89, 90,
+	70, 47, 94, 95, 36, 0, 107, 0, 27, 0,
+	0, 0, 112, 26, 18, 17, 0, 19, 0, 30,
 	0, 31, 0, 0, 20, 0, 0, 0, 21, 22,
-	35, 133, 0, 0, 23, 33, 0, 433, 34, 0,
-	0, 24, 0, 29, 86, 87, 0, 0, 0, 0,
-	0, 0, 106, 0, 51, 109, 0, 102, 98, 99,
-	100, 95, 96, 0, 0, 0, 0, 0, 0, 103,
-	0, 0, 0, 0, 134, 101, 97, 112, 0, 90,
-	91, 92, 0, 0, 0, 0, 85, 53, 0, 0,
-	0, 74, 75, 25, 0, 0, 0, 0, 0, 54,
-	55, 76, 63, 64, 65, 66, 67, 68, 69, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 104, 73, 14, 0,
-	32, 776, 60, 0, 52, 0, 0, 0, 57, 56,
-	58, 59, 71, 106, 88, 89, 70, 47, 93, 94,
-	36, 0, 105, 0, 27, 0, 0, 0, 110, 26,
+	35, 135, 106, 0, 23, 33, 0, 437, 34, 0,
+	0, 24, 0, 29, 87, 88, 181, 0, 0, 0,
+	0, 0, 108, 0, 51, 111, 0, 103, 99, 100,
+	101, 96, 97, 0, 0, 0, 0, 0, 0, 104,
+	0, 0, 0, 0, 136, 102, 98, 114, 0, 91,
+	92, 93, 0, 0, 0, 0, 86, 53, 167, 170,
+	171, 74, 75, 25, 0, 177, 179, 0, 0, 54,
+	55, 76, 63, 64, 65, 66, 67, 68, 69, 165,
+	164, 0, 0, 0, 0, 0, 0, 0, 0, 166,
+	168, 169, 176, 178, 163, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 105, 73, 14, 0,
+	32, 785, 60, 0, 52, 0, 0, 0, 57, 56,
+	58, 59, 71, 108, 89, 90, 70, 47, 94, 95,
+	36, 0, 107, 0, 27, 0, 0, 0, 112, 26,
 	18, 17, 0, 19, 0, 30, 0, 31, 0, 0,
-	20, 0, 0, 0, 21, 22, 35, 133, 0, 0,
+	20, 0, 0, 0, 21, 22, 35, 135, 106, 0,
 	23, 33, 0, 0, 34, 0, 0, 24, 0, 29,
-	86, 87, 0, 0, 0, 0, 0, 0, 0, 0,
-	51, 109, 0, 102, 98, 99, 100, 95, 96, 0,
-	0, 0, 0, 0, 0, 103, 0, 0, 0, 0,
-	134, 101, 97, 112, 0, 90, 91, 92, 0, 0,
-	0, 0, 85, 53, 0, 0, 0, 74, 75, 25,
+	87, 88, 0, 0, 0, 0, 0, 0, 0, 0,
+	51, 111, 0, 103, 99, 100, 101, 96, 97, 0,
+	0, 0, 0, 0, 0, 104, 0, 0, 0, 0,
+	136, 102, 98, 114, 0, 91, 92, 93, 0, 0,
+	0, 0, 86, 53, 0, 0, 0, 74, 75, 25,
 	0, 0, 0, 0, 0, 54, 55, 76, 63, 64,
 	65, 66, 67, 68, 69, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 104, 73, 14, 0, 32, 847, 60, 0,
-	52, 0, 0, 0, 57, 56, 58, 59, 71, 106,
-	88, 89, 70, 47, 93, 94, 36, 0, 105, 0,
-	27, 0, 0, 0, 110, 26, 18, 17, 0, 19,
+	0, 0, 105, 73, 14, 0, 32, 855, 60, 0,
+	52, 0, 0, 0, 57, 56, 58, 59, 71, 108,
+	89, 90, 70, 47, 94, 95, 36, 0, 107, 0,
+	27, 0, 0, 0, 112, 26, 18, 17, 0, 19,
 	0, 30, 0, 31, 0, 0, 20, 0, 0, 0,
-	21, 22, 35, 133, 0, 0, 23, 33, 0, 0,
-	34, 0, 0, 24, 0, 29, 86, 87, 0, 0,
-	0, 0, 0, 0, 0, 0, 51, 109, 0, 102,
-	98, 99, 100, 95, 96, 0, 0, 0, 0, 0,
-	0, 103, 0, 0, 0, 0, 134, 101, 97, 112,
-	0, 90, 91, 92, 0, 0, 0, 0, 85, 53,
+	21, 22, 35, 135, 106, 0, 23, 33, 0, 0,
+	34, 0, 0, 24, 0, 29, 87, 88, 0, 0,
+	0, 0, 0, 0, 0, 0, 51, 111, 0, 103,
+	99, 100, 101, 96, 97, 0, 0, 0, 0, 0,
+	0, 104, 0, 0, 0, 0, 136, 102, 98, 114,
+	0, 91, 92, 93, 0, 0, 0, 0, 86, 53,
 	0, 0, 0, 74, 75, 25, 0, 0, 0, 0,
 	0, 54, 55, 76, 63, 64, 65, 66, 67, 68,
 	69, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 104, 73,
-	14, 0, 32, 682, 60, 0, 52, 0, 0, 0,
-	57, 56, 58, 59, 71, 106, 88, 89, 70, 47,
-	93, 94, 36, 0, 105, 0, 27, 0, 0, 0,
-	110, 26, 18, 17, 0, 19, 0, 30, 0, 31,
-	0, 0, 20, 0, 0, 0, 21, 22, 35, 133,
-	0, 0, 23, 33, 0, 0, 34, 0, 0, 24,
-	0, 29, 86, 87, 0, 0, 0, 0, 0, 0,
-	0, 0, 51, 109, 0, 102, 98, 99, 100, 95,
-	96, 0, 0, 0, 0, 0, 0, 103, 0, 0,
-	0, 0, 134, 101, 97, 112, 0, 90, 91, 92,
-	0, 0, 0, 0, 85, 53, 0, 0, 0, 74,
+	0, 0, 0, 0, 0, 0, 0, 0, 105, 73,
+	14, 0, 32, 687, 60, 0, 52, 0, 0, 0,
+	57, 56, 58, 59, 71, 108, 89, 90, 70, 47,
+	94, 95, 36, 0, 107, 0, 27, 0, 0, 0,
+	112, 26, 18, 17, 0, 19, 0, 30, 0, 31,
+	0, 0, 20, 0, 0, 0, 21, 22, 35, 135,
+	106, 0, 23, 33, 0, 0, 34, 0, 0, 24,
+	0, 29, 87, 88, 0, 0, 0, 0, 0, 0,
+	0, 0, 51, 111, 0, 103, 99, 100, 101, 96,
+	97, 0, 0, 0, 0, 0, 0, 104, 0, 0,
+	0, 0, 136, 102, 98, 114, 0, 91, 92, 93,
+	0, 0, 0, 0, 86, 53, 0, 0, 0, 74,
 	75, 25, 0, 0, 0, 0, 0, 54, 55, 76,
 	63, 64, 65, 66, 67, 68, 69, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 104, 73, 14, 0, 32, 659,
+	0, 0, 0, 0, 105, 73, 14, 0, 32, 673,
 	60, 0, 52, 0, 0, 0, 57, 56, 58, 59,
-	71, 106, 88, 89, 70, 47, 93, 94, 36, 0,
-	105, 0, 27, 0, 0, 0, 110, 26, 18, 17,
+	71, 108, 89, 90, 70, 47, 94, 95, 36, 0,
+	107, 0, 27, 0, 0, 0, 112, 26, 18, 17,
 	0, 19, 0, 30, 0, 31, 0, 0, 20, 0,
-	0, 0, 21, 22, 35, 133, 0, 0, 23, 33,
-	0, 0, 34, 0, 0, 24, 0, 29, 86, 87,
-	0, 0, 0, 0, 0, 0, 0, 0, 51, 109,
-	0, 102, 98, 99, 100, 95, 96, 0, 0, 0,
-	0, 0, 0, 103, 0, 0, 0, 0, 134, 101,
-	97, 112, 0, 90, 91, 92, 0, 0, 0, 0,
-	85, 53, 0, 0, 0, 74, 75, 25, 0, 0,
+	0, 0, 21, 22, 35, 135, 106, 0, 23, 33,
+	0, 0, 34, 0, 0, 24, 0, 29, 87, 88,
+	0, 0, 0, 0, 0, 0, 0, 0, 51, 111,
+	0, 103, 99, 100, 101, 96, 97, 0, 0, 0,
+	0, 0, 0, 104, 0, 0, 0, 0, 136, 102,
+	98, 114, 0, 91, 92, 93, 0, 0, 0, 0,
+	86, 53, 0, 0, 0, 74, 75, 25, 0, 0,
 	0, 0, 0, 54, 55, 76, 63, 64, 65, 66,
 	67, 68, 69, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	104, 73, 14, 0, 32, 641, 60, 0, 52, 0,
-	0, 0, 57, 56, 58, 59, 71, 106, 88, 89,
-	70, 47, 93, 94, 36, 0, 105, 0, 27, 0,
-	0, 0, 110, 26, 18, 17, 0, 19, 0, 30,
+	105, 73, 14, 0, 32, 656, 60, 0, 52, 0,
+	0, 0, 57, 56, 58, 59, 71, 108, 89, 90,
+	70, 47, 94, 95, 36, 0, 107, 0, 27, 0,
+	0, 0, 112, 26, 18, 17, 0, 19, 0, 30,
 	0, 31, 0, 0, 20, 0, 0, 0, 21, 22,
-	35, 133, 0, 0, 23, 33, 0, 0, 34, 0,
-	0, 24, 0, 29, 86, 87, 0, 0, 0, 0,
-	0, 0, 0, 0, 51, 109, 0, 102, 98, 99,
-	100, 95, 96, 0, 0, 0, 0, 0, 0, 103,
-	0, 0, 0, 0, 134, 101, 97, 112, 0, 90,
-	91, 92, 0, 0, 0, 0, 85, 53, 0, 0,
+	35, 135, 106, 0, 23, 33, 0, 0, 34, 0,
+	0, 24, 0, 29, 87, 88, 0, 0, 0, 0,
+	0, 0, 0, 0, 51, 111, 0, 103, 99, 100,
+	101, 96, 97, 0, 0, 0, 0, 0, 0, 104,
+	0, 0, 0, 0, 136, 102, 98, 114, 0, 91,
+	92, 93, 0, 0, 0, 0, 86, 53, 0, 0,
 	0, 74, 75, 25, 0, 0, 0, 0, 0, 54,
 	55, 76, 63, 64, 65, 66, 67, 68, 69, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 104, 73, 14, 0,
+	0, 0, 0, 0, 0, 0, 105, 73, 14, 0,
 	32, 0, 60, 0, 52, 0, 0, 0, 57, 56,
-	58, 59, 71, 106, 443, 444, 454, 455, 0, 0,
-	882, 0, 0, 0, 0, 0, 0, 0, 0, 459,
-	460, 461, 462, 463, 464, 465, 466, 467, 468, 469,
-	489, 490, 491, 492, 493, 481, 482, 483, 0, 484,
-	485, 470, 471, 472, 473, 474, 475, 476, 477, 478,
-	479, 480, 0, 501, 499, 500, 496, 497, 0, 0,
-	488, 494, 495, 502, 503, 505, 504, 506, 507, 0,
+	58, 59, 71, 108, 447, 448, 458, 459, 0, 0,
+	887, 0, 0, 0, 0, 0, 0, 0, 0, 463,
+	464, 465, 466, 467, 468, 469, 470, 471, 472, 473,
+	493, 494, 495, 496, 497, 485, 486, 487, 514, 488,
+	489, 474, 475, 476, 477, 478, 479, 480, 481, 482,
+	483, 484, 0, 505, 503, 504, 500, 501, 0, 0,
+	492, 498, 499, 506, 507, 509, 508, 510, 511, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	881, 509, 508, 112, 0, 445, 446, 447, 448, 449,
-	450, 451, 452, 453, 456, 457, 458, 486, 487, 437,
-	438, 439, 440, 441, 442, 0, 0, 0, 0, 0,
-	0, 443, 444, 454, 455, 0, 0, 882, 0, 0,
-	0, 0, 0, 0, 0, 0, 459, 460, 461, 462,
-	463, 464, 465, 466, 467, 468, 469, 489, 490, 491,
-	492, 493, 481, 482, 483, 900, 484, 485, 470, 471,
-	472, 473, 474, 475, 476, 477, 478, 479, 480, 0,
-	501, 499, 500, 496, 497, 0, 0, 488, 494, 495,
-	502, 503, 505, 504, 506, 507, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 881, 509, 508,
-	112, 0, 445, 446, 447, 448, 449, 450, 451, 452,
-	453, 456, 457, 458, 486, 487, 437, 438, 439, 440,
-	441, 442, 88, 89, 70, 0, 93, 94, 117, 0,
-	105, 0, 0, 0, 0, 0, 110, 0, 0, 0,
+	886, 513, 512, 114, 0, 449, 450, 451, 452, 453,
+	454, 455, 456, 457, 460, 461, 462, 490, 491, 441,
+	442, 443, 444, 445, 446, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 133, 0, 0, 0, 0,
-	0, 0, 872, 0, 0, 0, 0, 0, 86, 87,
-	0, 0, 0, 0, 0, 0, 0, 0, 51, 109,
-	0, 102, 98, 99, 100, 95, 96, 0, 0, 0,
-	0, 0, 0, 103, 0, 0, 0, 0, 134, 101,
-	97, 112, 534, 90, 91, 92, 0, 0, 0, 0,
-	85, 53, 0, 0, 0, 74, 75, 139, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 447, 448, 458, 459, 0, 0, 887, 0, 0,
+	0, 0, 0, 0, 0, 905, 463, 464, 465, 466,
+	467, 468, 469, 470, 471, 472, 473, 493, 494, 495,
+	496, 497, 485, 486, 487, 514, 488, 489, 474, 475,
+	476, 477, 478, 479, 480, 481, 482, 483, 484, 0,
+	505, 503, 504, 500, 501, 0, 0, 492, 498, 499,
+	506, 507, 509, 508, 510, 511, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 886, 513, 512,
+	114, 0, 449, 450, 451, 452, 453, 454, 455, 456,
+	457, 460, 461, 462, 490, 491, 441, 442, 443, 444,
+	445, 446, 89, 90, 70, 0, 94, 95, 119, 0,
+	107, 0, 0, 0, 0, 0, 112, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 135, 106, 0, 0, 0,
+	0, 0, 877, 0, 0, 0, 0, 0, 87, 88,
+	0, 0, 0, 0, 0, 0, 0, 0, 51, 111,
+	0, 103, 99, 100, 101, 96, 97, 0, 0, 0,
+	0, 0, 0, 104, 0, 0, 0, 0, 136, 102,
+	98, 114, 540, 91, 92, 93, 0, 0, 0, 0,
+	86, 53, 0, 0, 0, 74, 75, 141, 0, 0,
 	0, 0, 0, 54, 55, 76, 63, 64, 65, 66,
-	67, 68, 69, 0, 0, 0, 88, 89, 70, 0,
-	93, 94, 117, 0, 105, 0, 0, 0, 0, 0,
-	110, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	104, 73, 0, 0, 0, 0, 60, 530, 52, 133,
-	0, 0, 57, 56, 58, 59, 71, 106, 0, 0,
-	0, 0, 86, 87, 0, 0, 0, 0, 0, 0,
-	0, 0, 227, 109, 0, 102, 98, 99, 100, 95,
-	96, 0, 0, 0, 0, 0, 0, 103, 0, 0,
-	0, 0, 134, 101, 97, 112, 0, 90, 91, 92,
-	0, 0, 0, 0, 85, 53, 0, 0, 0, 74,
-	75, 139, 0, 0, 0, 0, 0, 54, 55, 76,
-	63, 64, 65, 66, 67, 68, 69, 0, 88, 89,
-	70, 0, 93, 94, 117, 0, 105, 0, 0, 0,
-	0, 0, 110, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 104, 73, 0, 0, 0, 0,
-	60, 133, 52, 0, 0, 226, 57, 56, 58, 59,
-	71, 106, 0, 0, 86, 87, 0, 0, 0, 0,
-	0, 0, 0, 0, 51, 109, 0, 102, 98, 99,
-	100, 95, 96, 0, 0, 0, 0, 0, 0, 103,
-	0, 0, 0, 0, 134, 101, 97, 112, 534, 90,
-	91, 92, 0, 0, 0, 0, 85, 53, 0, 0,
-	0, 74, 75, 139, 0, 0, 0, 0, 0, 54,
-	55, 76, 63, 64, 65, 66, 67, 68, 69, 0,
-	88, 89, 70, 0, 93, 94, 117, 0, 105, 0,
-	0, 0, 0, 0, 110, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 104, 73, 0, 0,
-	0, 0, 60, 133, 52, 0, 0, 0, 57, 56,
-	58, 59, 71, 106, 0, 0, 86, 87, 0, 0,
-	0, 0, 0, 0, 0, 0, 594, 109, 0, 102,
-	98, 99, 100, 95, 96, 0, 0, 0, 0, 0,
-	0, 103, 0, 0, 0, 0, 134, 101, 97, 112,
-	0, 90, 91, 92, 0, 0, 0, 0, 85, 53,
-	0, 0, 0, 74, 75, 139, 0, 0, 0, 0,
+	67, 68, 69, 0, 0, 0, 89, 90, 70, 0,
+	94, 95, 119, 0, 107, 0, 0, 0, 0, 0,
+	112, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	105, 73, 0, 0, 0, 0, 60, 536, 52, 135,
+	106, 0, 57, 56, 58, 59, 71, 108, 0, 0,
+	0, 0, 87, 88, 0, 0, 0, 0, 0, 0,
+	0, 0, 230, 111, 0, 103, 99, 100, 101, 96,
+	97, 0, 0, 0, 0, 0, 0, 104, 0, 0,
+	0, 0, 136, 102, 98, 114, 0, 91, 92, 93,
+	0, 0, 0, 0, 86, 53, 0, 0, 0, 74,
+	75, 141, 0, 0, 0, 0, 0, 54, 55, 76,
+	63, 64, 65, 66, 67, 68, 69, 0, 0, 0,
+	89, 90, 70, 0, 94, 95, 119, 0, 107, 0,
+	0, 0, 0, 0, 112, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 105, 73, 0, 0, 0, 0,
+	60, 0, 52, 135, 106, 229, 57, 56, 58, 59,
+	71, 108, 0, 0, 0, 0, 87, 88, 0, 0,
+	0, 0, 0, 0, 0, 0, 51, 111, 0, 103,
+	99, 100, 101, 96, 97, 0, 0, 0, 0, 0,
+	0, 104, 0, 0, 0, 0, 136, 102, 98, 114,
+	540, 91, 92, 93, 0, 0, 0, 0, 86, 53,
+	0, 0, 0, 74, 75, 141, 0, 0, 0, 0,
 	0, 54, 55, 76, 63, 64, 65, 66, 67, 68,
-	69, 0, 88, 89, 70, 0, 93, 94, 117, 426,
-	105, 0, 0, 0, 0, 0, 110, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 104, 73,
-	0, 0, 0, 0, 60, 133, 52, 0, 0, 593,
-	57, 56, 58, 59, 71, 106, 0, 0, 86, 87,
-	0, 0, 0, 0, 0, 0, 0, 0, 51, 109,
-	0, 102, 98, 99, 100, 95, 96, 0, 0, 0,
-	0, 0, 0, 103, 0, 0, 0, 0, 134, 101,
-	97, 112, 0, 90, 91, 92, 0, 0, 0, 0,
-	85, 53, 0, 0, 0, 74, 75, 139, 0, 0,
-	0, 0, 0, 54, 55, 76, 63, 64, 65, 66,
-	67, 68, 69, 0, 88, 89, 70, 0, 93, 94,
-	117, 0, 105, 0, 0, 0, 0, 0, 110, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	104, 73, 0, 0, 0, 0, 60, 133, 52, 0,
-	0, 0, 57, 56, 58, 59, 71, 106, 0, 0,
-	86, 87, 0, 0, 0, 0, 0, 0, 0, 0,
-	51, 109, 0, 102, 98, 99, 100, 95, 96, 0,
-	0, 0, 0, 0, 0, 103, 0, 0, 0, 0,
-	134, 101, 97, 112, 0, 90, 91, 92, 0, 0,
-	0, 0, 85, 53, 0, 0, 0, 74, 75, 139,
+	69, 0, 0, 0, 89, 90, 70, 0, 94, 95,
+	119, 0, 107, 0, 0, 0, 0, 0, 112, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 105, 73,
+	0, 0, 0, 0, 60, 0, 52, 135, 106, 0,
+	57, 56, 58, 59, 71, 108, 0, 0, 0, 0,
+	87, 88, 0, 0, 0, 0, 0, 0, 0, 0,
+	599, 111, 0, 103, 99, 100, 101, 96, 97, 0,
+	0, 0, 0, 0, 0, 104, 0, 0, 0, 0,
+	136, 102, 98, 114, 0, 91, 92, 93, 0, 0,
+	0, 0, 86, 53, 0, 0, 0, 74, 75, 141,
 	0, 0, 0, 0, 0, 54, 55, 76, 63, 64,
-	65, 66, 67, 68, 69, 0, 88, 89, 70, 0,
-	93, 94, 117, 0, 105, 0, 0, 0, 0, 0,
-	110, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 104, 73, 0, 0, 0, 0, 60, 133,
-	52, 0, 0, 389, 57, 56, 58, 59, 71, 106,
-	0, 0, 86, 87, 0, 0, 0, 0, 0, 0,
-	0, 0, 51, 109, 0, 102, 98, 99, 100, 95,
-	96, 0, 0, 0, 0, 0, 0, 103, 0, 0,
-	0, 0, 134, 101, 97, 112, 0, 90, 91, 92,
-	0, 0, 0, 0, 85, 53, 0, 0, 0, 74,
-	75, 139, 0, 0, 0, 0, 0, 54, 55, 76,
-	63, 64, 65, 66, 67, 68, 69, 0, 88, 89,
-	70, 0, 93, 94, 117, 0, 105, 0, 0, 0,
-	0, 0, 110, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 104, 73, 0, 0, 0, 365,
-	60, 133, 52, 0, 0, 0, 57, 56, 58, 59,
-	71, 106, 0, 0, 86, 87, 0, 0, 0, 0,
-	0, 0, 0, 0, 51, 109, 0, 102, 98, 99,
-	100, 95, 96, 0, 0, 0, 0, 0, 0, 103,
-	0, 0, 0, 0, 134, 101, 97, 112, 0, 90,
-	91, 92, 0, 0, 0, 0, 85, 53, 0, 0,
-	0, 74, 75, 139, 0, 0, 0, 0, 0, 54,
+	65, 66, 67, 68, 69, 0, 0, 0, 89, 90,
+	70, 0, 94, 95, 119, 430, 107, 0, 0, 0,
+	0, 0, 112, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 105, 73, 0, 0, 0, 0, 60, 0,
+	52, 135, 106, 598, 57, 56, 58, 59, 71, 108,
+	0, 0, 0, 0, 87, 88, 0, 0, 0, 0,
+	0, 0, 0, 0, 51, 111, 0, 103, 99, 100,
+	101, 96, 97, 0, 0, 0, 0, 0, 0, 104,
+	0, 0, 0, 0, 136, 102, 98, 114, 0, 91,
+	92, 93, 0, 0, 0, 0, 86, 53, 0, 0,
+	0, 74, 75, 141, 0, 0, 0, 0, 0, 54,
 	55, 76, 63, 64, 65, 66, 67, 68, 69, 0,
-	0, 155, 157, 156, 179, 0, 0, 0, 0, 0,
+	0, 0, 89, 90, 70, 0, 94, 95, 119, 0,
+	107, 0, 0, 0, 0, 0, 112, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 105, 73, 0, 0,
+	0, 0, 60, 0, 52, 135, 106, 0, 57, 56,
+	58, 59, 71, 108, 0, 0, 0, 0, 87, 88,
+	0, 0, 0, 0, 0, 0, 0, 0, 51, 111,
+	0, 103, 99, 100, 101, 96, 97, 0, 0, 0,
+	0, 0, 0, 104, 0, 0, 0, 0, 136, 102,
+	98, 114, 0, 91, 92, 93, 0, 0, 0, 0,
+	86, 53, 0, 0, 0, 74, 75, 141, 0, 0,
+	0, 0, 0, 54, 55, 76, 63, 64, 65, 66,
+	67, 68, 69, 0, 0, 0, 89, 90, 70, 0,
+	94, 95, 119, 0, 107, 0, 0, 0, 0, 0,
+	112, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	105, 73, 0, 0, 0, 0, 60, 0, 52, 135,
+	106, 392, 57, 56, 58, 59, 71, 108, 0, 0,
+	0, 0, 87, 88, 0, 0, 0, 0, 0, 0,
+	0, 0, 51, 111, 0, 103, 99, 100, 101, 96,
+	97, 0, 0, 0, 0, 0, 0, 104, 0, 0,
+	0, 0, 136, 102, 98, 114, 0, 91, 92, 93,
+	0, 0, 0, 0, 86, 53, 0, 0, 0, 74,
+	75, 141, 0, 0, 0, 0, 0, 54, 55, 76,
+	63, 64, 65, 66, 67, 68, 69, 0, 0, 0,
+	89, 90, 70, 0, 94, 95, 119, 0, 107, 0,
+	0, 0, 0, 0, 112, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 105, 73, 0, 0, 0, 368,
+	60, 0, 52, 135, 106, 0, 57, 56, 58, 59,
+	71, 108, 0, 0, 0, 0, 87, 88, 0, 0,
+	0, 0, 0, 0, 0, 0, 51, 111, 0, 103,
+	99, 100, 101, 96, 97, 0, 0, 0, 0, 0,
+	0, 104, 0, 0, 0, 0, 136, 102, 98, 114,
+	0, 91, 92, 93, 0, 0, 0, 0, 86, 53,
+	0, 0, 0, 74, 75, 141, 0, 0, 0, 0,
+	0, 54, 55, 76, 63, 64, 65, 66, 67, 68,
+	69, 0, 0, 157, 159, 158, 181, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 104, 73, 181, 178,
-	0, 0, 60, 0, 52, 0, 0, 0, 57, 56,
-	58, 59, 71, 106, 153, 154, 165, 168, 169, 170,
-	171, 172, 173, 175, 177, 0, 155, 157, 156, 179,
-	0, 0, 0, 0, 756, 180, 159, 163, 162, 0,
-	0, 0, 0, 0, 158, 0, 160, 164, 166, 167,
-	174, 176, 161, 181, 178, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 153,
-	154, 165, 168, 169, 170, 171, 172, 173, 175, 177,
-	0, 155, 157, 156, 179, 0, 0, 709, 0, 0,
-	180, 159, 163, 162, 0, 0, 0, 0, 0, 158,
-	0, 160, 164, 166, 167, 174, 176, 161, 181, 178,
+	0, 0, 0, 0, 0, 0, 0, 0, 105, 73,
+	183, 180, 0, 0, 60, 0, 52, 0, 0, 0,
+	57, 56, 58, 59, 71, 108, 155, 156, 167, 170,
+	171, 172, 173, 174, 175, 177, 179, 0, 157, 159,
+	158, 181, 0, 0, 0, 0, 761, 182, 161, 165,
+	164, 0, 0, 0, 0, 0, 160, 0, 162, 166,
+	168, 169, 176, 178, 163, 183, 180, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 153, 154, 165, 168, 169, 170,
-	171, 172, 173, 175, 177, 0, 0, 0, 694, 155,
-	157, 156, 179, 0, 0, 180, 159, 163, 162, 0,
-	0, 0, 0, 0, 158, 0, 160, 164, 166, 167,
-	174, 176, 161, 0, 0, 0, 181, 178, 0, 0,
+	0, 155, 156, 167, 170, 171, 172, 173, 174, 175,
+	177, 179, 0, 157, 159, 158, 181, 0, 0, 719,
+	0, 0, 182, 161, 165, 164, 0, 0, 0, 0,
+	0, 160, 0, 162, 166, 168, 169, 176, 178, 163,
+	183, 180, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 155, 156, 167, 170,
+	171, 172, 173, 174, 175, 177, 179, 0, 0, 0,
+	699, 157, 159, 158, 181, 0, 0, 182, 161, 165,
+	164, 0, 0, 0, 0, 0, 160, 0, 162, 166,
+	168, 169, 176, 178, 163, 0, 0, 0, 183, 180,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 153, 154, 165, 168, 169, 170, 171, 172,
-	173, 175, 177, 0, 0, 0, 692, 155, 157, 156,
-	179, 0, 0, 180, 159, 163, 162, 0, 0, 0,
-	0, 0, 158, 0, 160, 164, 166, 167, 174, 176,
-	161, 0, 0, 0, 181, 178, 0, 0, 0, 0,
+	0, 0, 0, 0, 155, 156, 167, 170, 171, 172,
+	173, 174, 175, 177, 179, 0, 0, 0, 697, 157,
+	159, 158, 181, 0, 0, 182, 161, 165, 164, 0,
+	0, 0, 0, 0, 160, 0, 162, 166, 168, 169,
+	176, 178, 163, 0, 0, 0, 183, 180, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	153, 154, 165, 168, 169, 170, 171, 172, 173, 175,
-	177, 0, 0, 0, 683, 155, 157, 156, 179, 0,
-	0, 180, 159, 163, 162, 0, 0, 0, 0, 0,
-	158, 0, 160, 164, 166, 167, 174, 176, 161, 0,
-	0, 0, 181, 178, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 153, 154,
-	165, 168, 169, 170, 171, 172, 173, 175, 177, 0,
-	155, 157, 156, 179, 0, 0, 679, 0, 0, 180,
-	159, 163, 162, 0, 0, 0, 0, 0, 158, 0,
-	160, 164, 166, 167, 174, 176, 161, 181, 178, 0,
+	0, 0, 155, 156, 167, 170, 171, 172, 173, 174,
+	175, 177, 179, 0, 0, 0, 688, 157, 159, 158,
+	181, 0, 0, 182, 161, 165, 164, 0, 0, 0,
+	0, 0, 160, 0, 162, 166, 168, 169, 176, 178,
+	163, 0, 0, 0, 183, 180, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 153, 154, 165, 168, 169, 170, 171,
-	172, 173, 175, 177, 0, 155, 157, 156, 179, 0,
-	0, 678, 0, 0, 180, 159, 163, 162, 0, 0,
-	0, 0, 0, 158, 0, 160, 164, 166, 167, 174,
-	176, 161, 181, 178, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 153, 154,
-	165, 168, 169, 170, 171, 172, 173, 175, 177, 0,
-	0, 0, 624, 155, 157, 156, 179, 0, 0, 180,
-	159, 163, 162, 0, 0, 0, 0, 0, 158, 0,
-	160, 164, 166, 167, 174, 176, 161, 0, 0, 0,
-	181, 178, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 153, 154, 165, 168,
-	169, 170, 171, 172, 173, 175, 177, 0, 155, 157,
-	156, 179, 0, 0, 623, 0, 0, 180, 159, 163,
-	162, 0, 0, 0, 0, 0, 158, 0, 160, 164,
-	166, 167, 174, 176, 161, 181, 178, 0, 0, 0,
+	155, 156, 167, 170, 171, 172, 173, 174, 175, 177,
+	179, 0, 157, 159, 158, 181, 0, 0, 684, 0,
+	0, 182, 161, 165, 164, 0, 0, 0, 0, 0,
+	160, 0, 162, 166, 168, 169, 176, 178, 163, 183,
+	180, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 155, 156, 167, 170, 171,
+	172, 173, 174, 175, 177, 179, 0, 157, 159, 158,
+	181, 0, 0, 683, 0, 0, 182, 161, 165, 164,
+	0, 0, 0, 0, 0, 160, 0, 162, 166, 168,
+	169, 176, 178, 163, 183, 180, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 153, 154, 165, 168, 169, 170, 171, 172, 173,
-	175, 177, 0, 155, 157, 156, 179, 0, 0, 622,
-	0, 0, 180, 159, 163, 162, 0, 0, 0, 0,
-	0, 158, 0, 160, 164, 166, 167, 174, 176, 161,
-	181, 178, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 153, 154, 165, 168,
-	169, 170, 171, 172, 173, 175, 177, 0, 0, 0,
-	605, 155, 157, 156, 179, 0, 0, 180, 159, 163,
-	162, 0, 0, 0, 0, 0, 158, 0, 160, 164,
-	166, 167, 174, 176, 161, 0, 0, 0, 181, 178,
+	155, 156, 167, 170, 171, 172, 173, 174, 175, 177,
+	179, 0, 0, 0, 639, 157, 159, 158, 181, 0,
+	0, 182, 161, 165, 164, 0, 0, 0, 0, 0,
+	160, 0, 162, 166, 168, 169, 176, 178, 163, 0,
+	0, 0, 183, 180, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 155, 156,
+	167, 170, 171, 172, 173, 174, 175, 177, 179, 0,
+	157, 159, 158, 181, 0, 0, 628, 0, 0, 182,
+	161, 165, 164, 0, 0, 0, 0, 0, 160, 0,
+	162, 166, 168, 169, 176, 178, 163, 183, 180, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 153, 154, 165, 168, 169, 170,
-	171, 172, 173, 175, 177, 0, 155, 157, 156, 179,
-	0, 0, 596, 0, 0, 180, 159, 163, 162, 0,
-	0, 0, 0, 0, 158, 0, 160, 164, 166, 167,
-	174, 176, 161, 181, 178, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 153,
-	154, 165, 168, 169, 170, 171, 172, 173, 175, 177,
-	567, 0, 0, 586, 155, 157, 156, 179, 0, 0,
-	180, 159, 163, 162, 0, 0, 0, 0, 0, 158,
-	0, 160, 164, 166, 167, 174, 176, 161, 0, 0,
-	0, 181, 178, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 153, 154, 165,
-	168, 169, 170, 171, 172, 173, 175, 177, 0, 155,
-	157, 156, 179, 0, 0, 584, 0, 0, 180, 159,
-	163, 162, 0, 0, 0, 0, 0, 158, 0, 160,
-	164, 166, 167, 174, 176, 161, 181, 178, 0, 0,
+	0, 0, 0, 155, 156, 167, 170, 171, 172, 173,
+	174, 175, 177, 179, 0, 157, 159, 158, 181, 0,
+	0, 627, 0, 0, 182, 161, 165, 164, 0, 0,
+	0, 0, 0, 160, 0, 162, 166, 168, 169, 176,
+	178, 163, 183, 180, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 155, 156,
+	167, 170, 171, 172, 173, 174, 175, 177, 179, 0,
+	0, 0, 610, 157, 159, 158, 181, 0, 0, 182,
+	161, 165, 164, 0, 0, 0, 0, 0, 160, 0,
+	162, 166, 168, 169, 176, 178, 163, 0, 0, 0,
+	183, 180, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 155, 156, 167, 170,
+	171, 172, 173, 174, 175, 177, 179, 0, 157, 159,
+	158, 181, 0, 0, 601, 0, 0, 182, 161, 165,
+	164, 0, 0, 0, 0, 0, 160, 0, 162, 166,
+	168, 169, 176, 178, 163, 183, 180, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 153, 154, 165, 168, 169, 170, 171, 172,
-	173, 175, 177, 0, 155, 157, 156, 179, 0, 0,
-	0, 0, 0, 180, 159, 163, 162, 0, 0, 0,
-	0, 0, 158, 0, 160, 164, 166, 167, 174, 176,
-	161, 181, 178, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 153, 154, 165,
-	168, 169, 170, 171, 172, 173, 175, 177, 0, 155,
-	157, 156, 179, 563, 0, 0, 0, 0, 180, 159,
-	163, 162, 0, 0, 0, 0, 0, 158, 0, 160,
-	164, 166, 167, 174, 176, 161, 181, 178, 0, 0,
+	0, 155, 156, 167, 170, 171, 172, 173, 174, 175,
+	177, 179, 572, 0, 0, 591, 157, 159, 158, 181,
+	0, 0, 182, 161, 165, 164, 0, 0, 0, 0,
+	0, 160, 0, 162, 166, 168, 169, 176, 178, 163,
+	0, 0, 0, 183, 180, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 155,
+	156, 167, 170, 171, 172, 173, 174, 175, 177, 179,
+	0, 157, 159, 158, 181, 0, 0, 589, 0, 0,
+	182, 161, 165, 164, 0, 0, 0, 0, 0, 160,
+	0, 162, 166, 168, 169, 176, 178, 163, 183, 180,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 153, 154, 165, 168, 169, 170, 171, 172,
-	173, 175, 177, 0, 155, 157, 156, 179, 0, 0,
-	557, 0, 0, 180, 159, 163, 162, 0, 0, 0,
-	0, 0, 158, 0, 160, 164, 166, 167, 174, 176,
-	161, 181, 178, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 153, 154, 165,
-	168, 169, 170, 171, 172, 173, 175, 177, 0, 155,
-	157, 156, 179, 0, 0, 553, 0, 0, 180, 159,
-	163, 162, 0, 0, 0, 0, 0, 158, 0, 160,
-	164, 166, 167, 174, 176, 161, 181, 178, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 412, 0,
-	0, 0, 153, 154, 165, 168, 169, 170, 171, 172,
-	173, 175, 177, 0, 0, 0, 0, 0, 0, 0,
-	417, 0, 0, 180, 159, 163, 162, 155, 157, 156,
-	179, 0, 158, 0, 160, 164, 166, 167, 174, 176,
-	161, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 181, 178, 0, 0, 0, 0,
+	0, 0, 0, 0, 155, 156, 167, 170, 171, 172,
+	173, 174, 175, 177, 179, 0, 157, 159, 158, 181,
+	0, 0, 0, 0, 0, 182, 161, 165, 164, 0,
+	0, 0, 0, 0, 160, 0, 162, 166, 168, 169,
+	176, 178, 163, 183, 180, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 155,
+	156, 167, 170, 171, 172, 173, 174, 175, 177, 179,
+	0, 157, 159, 158, 181, 568, 0, 0, 0, 0,
+	182, 161, 165, 164, 0, 0, 0, 0, 0, 160,
+	0, 162, 166, 168, 169, 176, 178, 163, 183, 180,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	153, 154, 165, 168, 169, 170, 171, 172, 173, 175,
-	177, 0, 155, 157, 156, 179, 0, 0, 0, 0,
-	0, 180, 159, 163, 162, 0, 0, 0, 0, 0,
-	158, 0, 160, 164, 166, 167, 174, 176, 161, 181,
-	178, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 153, 154, 165, 168, 169,
-	170, 171, 172, 173, 175, 177, 0, 0, 0, 0,
-	373, 155, 157, 156, 179, 0, 180, 159, 163, 162,
-	0, 0, 0, 0, 0, 158, 0, 160, 164, 166,
-	167, 174, 176, 161, 0, 0, 0, 0, 181, 178,
+	0, 0, 0, 0, 155, 156, 167, 170, 171, 172,
+	173, 174, 175, 177, 179, 0, 157, 159, 158, 181,
+	0, 0, 563, 0, 0, 182, 161, 165, 164, 0,
+	0, 0, 0, 0, 160, 0, 162, 166, 168, 169,
+	176, 178, 163, 183, 180, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 155,
+	156, 167, 170, 171, 172, 173, 174, 175, 177, 179,
+	0, 157, 159, 158, 181, 0, 0, 559, 0, 0,
+	182, 161, 165, 164, 0, 0, 0, 0, 0, 160,
+	0, 162, 166, 168, 169, 176, 178, 163, 183, 180,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 153, 154, 165, 168, 169, 170,
-	171, 172, 173, 175, 177, 0, 0, 0, 0, 152,
-	155, 157, 156, 179, 0, 180, 159, 163, 162, 0,
-	0, 0, 0, 0, 158, 0, 160, 164, 166, 167,
-	174, 176, 161, 0, 0, 0, 0, 181, 178, 0,
+	416, 0, 0, 0, 155, 156, 167, 170, 171, 172,
+	173, 174, 175, 177, 179, 0, 0, 0, 0, 0,
+	0, 0, 421, 0, 0, 182, 161, 165, 164, 157,
+	159, 158, 181, 0, 160, 0, 162, 166, 168, 169,
+	176, 178, 163, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 183, 180, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 153, 154, 165, 168, 169, 170, 171,
-	172, 173, 175, 177, 0, 0, 157, 156, 179, 0,
-	0, 0, 0, 0, 180, 159, 163, 162, 0, 0,
-	0, 0, 0, 158, 0, 160, 164, 166, 167, 174,
-	176, 161, 181, 178, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 153, 154,
-	165, 168, 169, 170, 171, 172, 173, 175, 177, 0,
-	0, 0, 156, 179, 0, 0, 0, 0, 0, 180,
-	159, 163, 162, 0, 0, 0, 0, 0, 158, 0,
-	160, 164, 166, 167, 174, 176, 161, 181, 178, 428,
+	0, 0, 155, 156, 167, 170, 171, 172, 173, 174,
+	175, 177, 179, 0, 157, 159, 158, 181, 0, 0,
+	0, 0, 0, 182, 161, 165, 164, 0, 0, 0,
+	0, 0, 160, 0, 162, 166, 168, 169, 176, 178,
+	163, 183, 180, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 155, 156, 167,
+	170, 171, 172, 173, 174, 175, 177, 179, 0, 0,
+	0, 0, 376, 157, 159, 158, 181, 0, 182, 161,
+	165, 164, 0, 0, 0, 0, 0, 160, 0, 162,
+	166, 168, 169, 176, 178, 163, 0, 0, 0, 0,
+	183, 180, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 155, 156, 167, 170,
+	171, 172, 173, 174, 175, 177, 179, 0, 0, 0,
+	0, 154, 157, 159, 158, 181, 0, 182, 161, 165,
+	164, 0, 0, 0, 0, 0, 160, 0, 162, 166,
+	168, 169, 176, 178, 163, 0, 0, 0, 0, 183,
+	180, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 155, 156, 167, 170, 171,
+	172, 173, 174, 175, 177, 179, 0, 0, 159, 158,
+	181, 0, 0, 0, 0, 0, 182, 161, 165, 164,
+	0, 0, 0, 0, 0, 160, 0, 162, 166, 168,
+	169, 176, 178, 163, 183, 180, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 153, 154, 165, 168, 169, 170, 171,
-	172, 173, 175, 177, 0, 0, 0, 0, 0, 0,
-	0, 179, 0, 0, 180, 159, 163, 162, 0, 0,
-	0, 0, 0, 158, 0, 160, 164, 166, 167, 174,
-	176, 161, 0, 0, 0, 181, 178, 0, 0, 0,
+	155, 156, 167, 170, 171, 172, 173, 174, 175, 177,
+	179, 0, 0, 0, 158, 181, 0, 0, 0, 0,
+	0, 182, 161, 165, 164, 0, 0, 0, 0, 0,
+	160, 0, 162, 166, 168, 169, 176, 178, 163, 183,
+	180, 432, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 155, 156, 167, 170, 171,
+	172, 173, 174, 175, 177, 179, 0, 0, 0, 0,
+	0, 0, 0, 181, 0, 0, 182, 161, 165, 164,
+	0, 0, 0, 0, 0, 160, 0, 162, 166, 168,
+	169, 176, 178, 163, 0, 0, 0, 183, 180, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 153, 154, 165, 168, 169, 170, 171, 172, 173,
-	175, 177, 0, 0, 0, 0, 179, 0, 0, 0,
-	0, 0, 180, 159, 163, 162, 0, 0, 0, 0,
-	0, 158, 0, 160, 164, 166, 167, 174, 176, 161,
-	181, 178, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 153, 154, 165, 168,
-	169, 170, 171, 172, 173, 175, 177, 0, 0, 0,
-	0, 179, 0, 0, 0, 0, 0, 180, 159, 163,
-	162, 0, 0, 0, 0, 0, 158, 0, 160, 164,
-	166, 167, 174, 176, 161, 181, 178, 0, 0, 0,
+	0, 0, 0, 155, 156, 167, 170, 171, 172, 173,
+	174, 175, 177, 179, 0, 0, 0, 0, 181, 0,
+	0, 0, 0, 0, 182, 161, 165, 164, 0, 0,
+	0, 0, 0, 160, 0, 162, 166, 168, 169, 176,
+	178, 163, 183, 180, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 155, 156,
+	167, 170, 171, 172, 173, 174, 175, 177, 179, 0,
+	0, 0, 0, 181, 0, 0, 0, 0, 0, 182,
+	161, 165, 164, 0, 0, 0, 0, 0, 160, 0,
+	162, 166, 168, 169, 176, 178, 163, 183, 180, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 153, 154, 165, 168, 169, 170, 171, 172, 173,
-	175, 177, 0, 0, 0, 179, 0, 0, 0, 0,
-	0, 0, 0, 159, 163, 162, 0, 0, 0, 0,
-	0, 158, 0, 160, 164, 166, 167, 174, 176, 161,
-	178, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 179, 154, 165, 168, 169,
-	170, 171, 172, 173, 175, 177, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 159, 163, 162,
-	178, 0, 0, 0, 0, 158, 0, 160, 164, 166,
-	167, 174, 176, 161, 0, 179, 0, 165, 168, 169,
-	170, 171, 172, 173, 175, 177, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 159, 163, 162,
-	178, 0, 0, 0, 0, 158, 0, 160, 164, 166,
-	167, 174, 176, 161, 0, 179, 0, 165, 168, 169,
-	170, 171, 172, 173, 175, 177, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 159, 163, 162,
-	178, 0, 0, 0, 0, 0, 0, 160, 164, 166,
-	167, 174, 176, 161, 0, 0, 0, 165, 168, 169,
-	170, 171, 172, 173, 175, 177, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 159, 163, 162,
-	443, 444, 454, 455, 0, 0, 434, 0, 164, 166,
-	167, 174, 176, 161, 0, 459, 460, 461, 462, 463,
-	464, 465, 466, 467, 468, 469, 489, 490, 491, 492,
-	493, 481, 482, 483, 0, 484, 485, 470, 471, 472,
-	473, 474, 475, 476, 477, 478, 479, 480, 0, 501,
-	499, 500, 496, 497, 0, 0, 488, 494, 495, 502,
-	503, 505, 504, 506, 507, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 498, 509, 508, 0,
-	0, 445, 446, 447, 448, 449, 450, 451, 452, 453,
-	456, 457, 458, 486, 487, 437, 438, 439, 440, 441,
-	442, 443, 444, 454, 455, 0, 0, 916, 0, 0,
-	0, 0, 0, 0, 0, 0, 459, 460, 461, 462,
-	463, 464, 465, 466, 467, 468, 469, 489, 490, 491,
-	492, 493, 481, 482, 483, 0, 484, 485, 470, 471,
-	472, 473, 474, 475, 476, 477, 478, 479, 480, 0,
-	501, 499, 500, 496, 497, 0, 0, 488, 494, 495,
-	502, 503, 505, 504, 506, 507, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 498, 509, 508,
-	0, 0, 445, 446, 447, 448, 449, 450, 451, 452,
-	453, 456, 457, 458, 486, 487, 745, 746, 747, 744,
-	743, 742,
+	0, 0, 0, 155, 156, 167, 170, 171, 172, 173,
+	174, 175, 177, 179, 0, 0, 0, 181, 0, 0,
+	0, 0, 0, 0, 0, 161, 165, 164, 0, 0,
+	0, 0, 0, 160, 0, 162, 166, 168, 169, 176,
+	178, 163, 180, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 181, 156, 167,
+	170, 171, 172, 173, 174, 175, 177, 179, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 161,
+	165, 164, 180, 0, 0, 0, 0, 160, 0, 162,
+	166, 168, 169, 176, 178, 163, 0, 181, 0, 167,
+	170, 171, 172, 173, 174, 175, 177, 179, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 161,
+	165, 164, 180, 0, 0, 0, 0, 160, 0, 162,
+	166, 168, 169, 176, 178, 163, 0, 181, 0, 167,
+	170, 171, 172, 173, 174, 175, 177, 179, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 161,
+	165, 164, 180, 0, 0, 0, 0, 0, 0, 162,
+	166, 168, 169, 176, 178, 163, 0, 181, 0, 167,
+	170, 171, 172, 173, 174, 175, 177, 179, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 161,
+	165, 164, 180, 0, 0, 0, 0, 0, 0, 0,
+	166, 168, 169, 176, 178, 163, 0, 0, 0, 167,
+	170, 171, 172, 173, 174, 175, 177, 179, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	165, 164, 447, 448, 458, 459, 0, 0, 438, 0,
+	166, 168, 169, 176, 178, 163, 0, 463, 464, 465,
+	466, 467, 468, 469, 470, 471, 472, 473, 493, 494,
+	495, 496, 497, 485, 486, 487, 514, 488, 489, 474,
+	475, 476, 477, 478, 479, 480, 481, 482, 483, 484,
+	0, 505, 503, 504, 500, 501, 0, 0, 492, 498,
+	499, 506, 507, 509, 508, 510, 511, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 502, 513,
+	512, 0, 0, 449, 450, 451, 452, 453, 454, 455,
+	456, 457, 460, 461, 462, 490, 491, 441, 442, 443,
+	444, 445, 446, 447, 448, 458, 459, 0, 0, 920,
+	0, 0, 0, 0, 0, 0, 0, 0, 463, 464,
+	465, 466, 467, 468, 469, 470, 471, 472, 473, 493,
+	494, 495, 496, 497, 485, 486, 487, 514, 488, 489,
+	474, 475, 476, 477, 478, 479, 480, 481, 482, 483,
+	484, 0, 505, 503, 504, 500, 501, 0, 0, 492,
+	498, 499, 506, 507, 509, 508, 510, 511, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 502,
+	513, 512, 0, 0, 449, 450, 451, 452, 453, 454,
+	455, 456, 457, 460, 461, 462, 490, 491, 750, 751,
+	752, 749, 748, 747,
 }
 var yyPact = [...]int{
 
-	-1000, -1000, 1245, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-	280, 510, 594, 787, -1000, -1000, -1000, 279, 4494, 273,
-	272, 5644, 5644, 5644, 140, 733, 5644, -1000, 6863, 270,
-	269, 268, -1000, 425, 5644, 827, 297, 62, 541, 822,
-	821, 819, 501, 507, -11, -1000, -1000, 266, -1000, -1000,
-	253, 263, 4972, 5644, 343, 343, 5644, 5644, 5644, 5644,
-	5644, -1000, -1000, 5644, 5644, 5644, 5644, 5644, 5644, 5644,
-	262, 5644, -1000, 818, 5644, 5644, 5644, -1000, -1000, -1000,
-	73, -1000, 547, 540, -1000, 180, 261, 259, 5644, 5644,
-	258, 5644, 5644, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-	-1000, -1000, -1000, 816, 802, -1000, 115, 208, 208, 245,
-	-1000, 523, 781, 195, 781, 322, -1000, -1000, 358, 630,
-	92, 646, 781, -1000, -1000, -1000, -1000, 85, -1000, -60,
-	3299, 5644, 706, 62, 516, 5644, 5644, 354, 6922, 644,
-	352, 346, 82, -1000, -1000, 70, 62, -1000, -61, -15,
-	-1000, 6922, -1000, 5644, 5644, 5644, 5644, 5644, 5644, 5644,
-	5644, 5644, 5644, 5644, 5644, 5644, 5644, 5644, 5644, 5644,
-	5644, 5644, 5644, 5644, 5644, 5644, 5644, 5644, 5644, 210,
-	5532, 5644, 343, 5644, 787, -1000, 6804, 344, -1000, 815,
-	-1000, 813, -1000, 576, -1000, 580, 244, 4494, 237, 341,
-	296, 5420, 5644, 5644, 5644, 5644, 5644, 5644, 5644, 5644,
-	5644, 5644, 5644, 5644, -1000, -1000, 5644, 5644, 5644, 110,
-	4972, 104, 28, -1000, -1000, 6749, 343, 230, -1000, -1000,
-	73, 5644, -1000, -1000, 4972, -1000, 380, 380, 490, 380,
-	6681, 380, 380, 380, 380, 380, 380, 380, -1000, 5644,
-	380, 435, 722, 683, -1000, 169, 5308, 343, 7145, 7090,
-	7145, 5644, 3613, 3613, 208, -1000, 530, 207, 208, -1000,
-	-1000, 5644, 5644, 6922, 6922, 5644, 6922, 6922, 704, -1000,
-	786, 613, 722, 5644, -1000, -1000, 4858, -1000, 4972, 805,
-	523, 338, 523, -1000, -1000, 1087, -1000, 325, -16, 642,
-	781, -1000, 629, 543, 801, 609, -1000, -1000, 787, 5644,
-	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 223, 6626,
-	215, -1000, 324, 23, 6922, 6571, -1000, -1000, -1000, -1000,
-	140, -1000, 775, -1000, 5644, -1000, 5644, 7254, 7294, 6977,
-	7145, 7032, 7334, 408, 7374, 167, 167, 167, 490, 380,
-	490, 490, 368, 368, 480, 480, 480, 480, 148, 148,
-	148, 148, 480, -1000, 6516, 5644, 7200, -7, -1000, -1000,
-	6461, 40, 3141, -1000, -1000, -1000, 214, 576, 572, 648,
-	416, -1000, 648, 5644, -1000, 5644, -1000, -1000, 7145, 5644,
-	7145, 7145, 7145, 7145, 7145, 7145, 7145, 7145, 7145, 7145,
-	7145, 7145, 6406, 102, 6348, 208, -1000, 5644, -1000, 189,
-	-66, 4972, 5196, -1000, 4972, 6293, 100, -1000, 185, -1000,
-	-1000, -1000, -1000, 282, 785, 6235, 146, 376, 5644, 98,
-	208, -1000, -1000, 5644, -1000, -1000, -1000, -1000, -1000, -1000,
+	-1000, -1000, 1253, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
+	265, 433, 613, 722, -1000, -1000, -1000, 262, 4344, 261,
+	259, 5526, 5526, 5526, 136, 711, 5526, -1000, 6745, 258,
+	254, 253, -1000, 413, 5526, 775, 290, 0, 530, 771,
+	770, 756, 504, 513, 409, -1000, -1000, 250, -1000, -1000,
+	223, 247, 4842, 5526, 222, 222, 5526, 5526, 5526, 5526,
+	5526, -1000, -1000, 5526, 5526, 5526, 5526, 5526, 5526, 5526,
+	240, 5526, -1000, 876, 5526, 5526, 5526, -1000, -1000, -1000,
+	-1000, 86, -1000, 535, 514, -1000, 539, 236, 230, 5526,
+	5526, 228, 5526, 5526, -1000, -1000, -1000, -1000, -1000, -1000,
+	-1000, -1000, -1000, -1000, 758, 856, 0, -1000, 110, 176,
+	176, 226, -1000, 482, 709, 159, 709, 302, -1000, -1000,
+	353, 616, 77, 634, 709, -1000, -1000, -1000, -1000, 42,
+	-1000, -49, 3149, 5526, 627, 0, 475, 5526, 5526, 352,
+	6804, 647, 351, 350, 41, -1000, -1000, 39, -1000, -1000,
+	-53, -18, -1000, 6804, -1000, 5526, 5526, 5526, 5526, 5526,
+	5526, 5526, 5526, 5526, 5526, 5526, 5526, 5526, 5526, 5526,
+	5526, 5526, 5526, 5526, 5526, 5526, 5526, 5526, 5526, 5526,
+	5526, 252, 5412, 5526, 222, 5526, 722, -1000, 6686, 344,
+	-1000, 753, -1000, 746, -1000, 569, -1000, 577, 220, 4344,
+	215, 343, 275, 5298, 5526, 5526, 5526, 5526, 5526, 5526,
+	5526, 5526, 5526, 5526, 5526, 5526, 5526, -1000, -1000, 5526,
+	5526, 5526, 98, 4842, 92, -10, -1000, -1000, 6631, 222,
+	211, -1000, -1000, 86, 5526, -1000, -1000, 4842, -1000, 415,
+	415, 469, 415, 6563, 415, 415, 415, 415, 415, 415,
+	415, -1000, 5526, 415, 400, 700, 847, -1000, 191, 5184,
+	222, 7027, 6972, 7027, 5526, 3463, 3463, 176, -1000, 505,
+	210, 176, -1000, -1000, 5526, 5526, 6804, 6804, 5526, 6804,
+	6804, 691, -1000, 740, 501, 700, 207, 5526, -1000, -1000,
+	4728, -1000, 4842, 728, 482, 342, 482, -1000, -1000, 1095,
+	-1000, 337, -28, 582, 709, -1000, 600, 516, 725, 574,
+	-1000, -1000, 722, 5526, -1000, -1000, -1000, -1000, -1000, -1000,
+	-1000, -1000, 200, 6508, 199, -1000, 336, -11, 6804, 6453,
+	-1000, -1000, -1000, -1000, 136, -1000, 708, 5526, -1000, 5526,
+	7136, 7176, 6859, 7027, 6914, 7216, 7296, 7256, 64, 64,
+	64, 469, 415, 469, 469, 164, 164, 3525, 3525, 3525,
+	3525, 270, 270, 270, 270, 3525, -1000, 6398, 5526, 7082,
+	-13, -1000, -1000, 6343, -30, 2991, -1000, -1000, -1000, 186,
+	569, 563, 635, 410, -1000, 635, 5526, -1000, 5526, -1000,
+	-1000, 7027, 5526, 7027, 7027, 7027, 7027, 7027, 7027, 7027,
+	7027, 7027, 7027, 7027, 7027, 6804, 6288, 88, 6230, 176,
+	-1000, 5526, -1000, 157, -55, 4842, 5070, -1000, 4842, 6175,
+	76, -1000, 155, -1000, -1000, -1000, -1000, 272, 719, 6117,
+	81, 366, 5526, 49, 176, -1000, -1000, 5526, -1000, -1000,
 	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
 	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
 	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
@@ -1377,98 +1369,98 @@ var yyPact = [...]int{
 	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
 	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
 	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-	208, -1000, -1000, -1000, -1000, 140, 5644, 5644, 110, 140,
-	576, -12, -1000, 6922, 6180, 6125, -1000, -1000, -1000, 6067,
-	-1000, -13, -1000, 6922, 5644, 179, -1000, -1000, 929, -1000,
-	-1000, -1000, 528, 599, -1000, 781, 595, 779, -1000, 526,
-	-1000, 6922, 177, 4338, 5644, 5644, 5644, 233, -1000, -1000,
-	206, 6922, -1000, 5644, 7200, 176, 343, 792, 4182, -1000,
-	204, 287, 572, -1000, 648, -1000, -1000, 410, -55, -1000,
-	6012, 5957, 2983, 408, 4026, -1000, -1000, -1000, 5899, -75,
-	5644, -1000, 6922, 343, 202, 174, -1000, -1000, -1000, 97,
-	-1000, -1000, 680, -1000, -1000, -1000, -1000, 5644, -1000, 7145,
-	-1000, -1000, 5841, -1000, -1000, 95, 5783, -1000, -1000, 572,
-	173, 5644, -1000, -1000, -1000, 159, 5084, 6922, -1000, -1000,
-	781, 521, -32, -1000, -1000, 781, 779, -1000, 323, -1000,
-	-1000, -1000, 5728, 321, 6922, -1000, 319, 318, 287, 7200,
-	315, -1000, 158, 548, 343, 198, 4972, -1000, -1000, -1000,
-	661, 287, 156, -14, -1000, 72, -1000, -1000, 676, -1000,
-	-1000, -1000, -1000, 406, -55, 1427, -1000, 648, 4494, 293,
-	314, -1000, -1000, -1000, 5644, 7145, -1000, 4972, -75, -1000,
-	-1000, 5673, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-	-54, -1000, 781, 374, 779, -1000, -32, -1000, 2825, 309,
-	5644, 453, -1000, 837, -1000, 155, -1000, 3714, 792, -1000,
-	4972, 89, 2667, -1000, 181, 396, 139, 607, 287, 503,
-	-1000, -1000, 395, -1000, -1000, -1000, 765, 747, 648, 664,
-	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1269, -1000,
-	-1000, -1000, -1000, 3457, 7145, 129, 371, 385, 370, 781,
-	-54, -1000, -1000, 369, 306, -1000, 128, -1000, 5644, 213,
-	421, 305, 774, 607, -1000, -1000, -1000, 126, -1000, 122,
-	-1000, 304, 648, -1000, 234, 234, 170, -1000, 771, -1000,
-	-1000, 1111, -17, -1000, -71, 7526, 62, -21, -1000, -1000,
-	3457, -75, -1000, -1000, -1000, -1000, 367, -1000, -1000, 3870,
-	342, -1000, -1000, -1000, -1000, -1000, 303, 234, 2509, 3714,
-	-1000, -1000, 76, -1000, 2351, 384, 287, 383, 183, -76,
-	953, -1000, -1000, 765, -1000, 5644, -20, -1000, -77, 7526,
-	-1000, -1000, 4757, 672, -1000, -1000, -1000, -1000, -1000, 3457,
-	-1000, 382, 302, -1000, 119, 648, -1000, -1000, -1000, -1000,
-	-25, -1000, -1000, 730, 5644, -1000, -1000, 6922, -1000, 7526,
-	5644, -1000, -1000, 4650, -1000, 300, 299, 605, 694, 511,
-	-1000, 516, -1000, -1000, 2193, 3457, -1000, -1000, 381, -1000,
-	2035, 1877, -1000, 183, -1000, 6922, -1000, -1000, 6922, 168,
-	-1000, -1000, -1000, -1000, 648, 7627, 7526, 292, 1719, -1000,
-	-1000, -1000, -1000, -1000, 287, -55, -1000, -1000, 7526, -1000,
-	-1000, -1000, 1561, 94, -1000, -1000, 234, 291, -1000, -1000,
-	-1000, 1403, -1000,
+	-1000, -1000, -1000, -1000, -1000, 176, -1000, -1000, -1000, -1000,
+	136, 5526, 5526, 98, 136, 569, -15, -1000, 6804, 6062,
+	6007, -1000, -1000, -1000, 404, 5949, -1000, -16, -1000, 6804,
+	5526, 154, -1000, -1000, 937, -1000, -1000, -1000, 515, 566,
+	-1000, 709, 552, 685, -1000, 507, -1000, 6804, 152, 4188,
+	5526, 5526, 5526, 202, -1000, -1000, 6804, -1000, 5526, 7082,
+	151, 222, 297, 4032, -1000, 174, 404, 563, -1000, 635,
+	-1000, -1000, 406, -39, -1000, 5894, 5839, 2833, 7296, 3876,
+	-1000, -1000, -1000, 5781, -59, 5526, -1000, 6804, 222, 172,
+	147, -1000, -1000, -1000, 47, -1000, -1000, 643, -1000, -1000,
+	-1000, -1000, 5526, -1000, 7027, -1000, -1000, 5723, -1000, -1000,
+	43, 5665, -1000, -1000, 563, 141, 5526, -1000, -1000, 138,
+	-33, -1000, 1, -1000, -1000, 749, -1000, -1000, -1000, -1000,
+	131, 4956, 6804, -1000, -1000, 709, 502, -34, -1000, -1000,
+	709, 685, -1000, 335, -1000, -1000, -1000, 5610, 323, 6804,
+	-1000, 322, 321, 7082, 318, -1000, 124, 558, 222, 168,
+	4842, -1000, -1000, -1000, 619, 404, 118, -1000, 403, -39,
+	1277, -1000, 635, 4344, 203, 317, -1000, -1000, -1000, 5526,
+	7027, -1000, 4842, -59, -1000, -1000, 5555, -1000, -1000, -1000,
+	-1000, -1000, -1000, 100, 404, 468, -1000, -1000, -1000, -1000,
+	-36, -1000, 709, 365, 685, -1000, -34, -1000, 2675, 315,
+	5526, 408, -1000, 773, -1000, -1000, 3564, 297, -1000, 4842,
+	40, 2517, -1000, 162, 401, 112, 594, 398, -1000, -1000,
+	-1000, 680, 707, 635, 607, -1000, -1000, -1000, -1000, -1000,
+	-1000, -1000, -1000, 1119, -1000, -1000, -1000, -1000, 3307, 7027,
+	107, 364, 396, -1000, 404, -1000, 701, -1000, 356, 709,
+	-36, -1000, -1000, 255, 314, -1000, 103, -1000, 5526, 166,
+	399, 313, 741, -1000, -1000, -1000, 102, -1000, 101, -1000,
+	312, 635, -1000, 100, 100, 111, -1000, 961, -29, -1000,
+	-57, 7448, 0, -40, -1000, -1000, 3307, -59, -1000, -1000,
+	527, -1000, -63, -1000, -1000, 45, -1000, -1000, 3720, 339,
+	-1000, -1000, -1000, -1000, -1000, 311, 2359, 3564, -1000, -1000,
+	85, -1000, 2201, 380, 377, 139, 778, -1000, -1000, 680,
+	-1000, 5526, -31, -1000, -70, 7448, -1000, -1000, 4627, 744,
+	5526, 5526, -1000, -1000, -1000, -1000, -1000, 3307, -1000, 306,
+	-1000, 99, 635, -1000, -1000, -1000, -35, -1000, -1000, 676,
+	-1000, -1000, 6804, -1000, 7448, 5526, -1000, -1000, 4500, -1000,
+	303, 298, 590, 615, 488, -1000, 475, -1000, -1000, 7027,
+	6804, 2043, 3307, -1000, 375, -1000, 1885, 1727, -1000, 139,
+	-1000, -1000, -1000, 6804, 44, -1000, -1000, -1000, -1000, 635,
+	7549, 7448, 296, -1000, -1000, -1000, -1000, -1000, 404, -39,
+	-1000, -1000, 7448, -1000, -1000, 1569, 96, -1000, -1000, 100,
+	274, -1000, -1000, -1000, 1411, -1000,
 }
 var yyPgo = [...]int{
 
-	0, 1003, 1002, 51, 9, 1000, 3, 29, 16, 999,
-	11, 31, 79, 78, 49, 45, 991, 21, 988, 73,
-	19, 55, 987, 0, 80, 986, 985, 38, 141, 25,
-	977, 36, 975, 56, 62, 972, 10, 971, 967, 962,
-	961, 13, 46, 960, 958, 100, 84, 199, 957, 955,
-	953, 5, 946, 83, 40, 944, 138, 43, 930, 928,
-	927, 925, 924, 119, 923, 921, 920, 918, 12, 917,
-	913, 44, 42, 32, 2, 15, 668, 41, 74, 909,
-	908, 907, 14, 906, 904, 47, 39, 903, 18, 8,
-	809, 20, 592, 902, 121, 901, 900, 898, 71, 897,
-	33, 890, 889, 30, 37, 887, 886, 28, 883, 876,
-	579, 873, 866, 858, 26, 856, 63, 1, 4, 855,
-	17, 845, 844, 840, 7, 839, 6, 812,
+	0, 937, 936, 16, 9, 931, 4, 28, 13, 929,
+	11, 44, 79, 71, 52, 45, 928, 25, 926, 83,
+	21, 62, 918, 0, 78, 914, 912, 40, 81, 38,
+	911, 32, 910, 73, 49, 908, 6, 907, 906, 904,
+	903, 14, 51, 902, 901, 95, 96, 116, 900, 899,
+	898, 5, 897, 86, 50, 896, 56, 33, 895, 894,
+	892, 891, 886, 80, 884, 875, 871, 870, 12, 869,
+	865, 46, 39, 41, 2, 17, 726, 85, 84, 862,
+	861, 856, 10, 855, 849, 559, 42, 43, 841, 840,
+	8, 691, 19, 576, 839, 18, 831, 830, 828, 87,
+	827, 20, 824, 821, 29, 26, 820, 815, 37, 814,
+	813, 564, 808, 807, 802, 34, 801, 100, 1, 3,
+	798, 15, 795, 793, 790, 7, 786, 36, 783,
 }
 var yyR1 = [...]int{
 
-	0, 127, 4, 4, 4, 4, 4, 4, 4, 4,
+	0, 128, 4, 4, 4, 4, 4, 4, 4, 4,
 	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-	4, 4, 4, 4, 4, 4, 4, 4, 4, 5,
-	5, 5, 5, 5, 5, 5, 6, 6, 116, 116,
-	94, 94, 10, 10, 10, 9, 9, 9, 9, 9,
+	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+	5, 5, 5, 5, 5, 5, 5, 6, 6, 117,
+	117, 95, 95, 10, 10, 10, 9, 9, 9, 9,
 	9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
-	90, 90, 16, 16, 18, 18, 7, 7, 104, 104,
-	103, 103, 110, 110, 17, 17, 20, 20, 19, 19,
-	98, 98, 117, 117, 22, 22, 22, 22, 22, 22,
-	22, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+	9, 91, 91, 16, 16, 18, 18, 7, 7, 105,
+	105, 104, 104, 111, 111, 17, 17, 20, 20, 19,
+	19, 99, 99, 118, 118, 22, 22, 22, 22, 22,
+	22, 22, 11, 11, 11, 11, 11, 11, 11, 11,
 	11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-	11, 11, 11, 11, 11, 96, 96, 95, 95, 26,
-	26, 109, 109, 27, 12, 1, 1, 2, 2, 13,
-	13, 125, 125, 76, 76, 14, 15, 85, 85, 87,
-	87, 86, 86, 91, 91, 91, 91, 83, 83, 82,
-	82, 25, 25, 80, 80, 80, 80, 107, 107, 107,
-	8, 8, 84, 84, 67, 67, 65, 65, 69, 69,
-	66, 66, 118, 118, 119, 119, 29, 29, 30, 30,
-	75, 75, 73, 73, 73, 74, 74, 77, 77, 115,
-	115, 31, 31, 102, 102, 33, 106, 106, 34, 34,
-	120, 120, 35, 35, 35, 35, 124, 124, 79, 79,
-	79, 108, 108, 36, 36, 37, 38, 38, 38, 38,
-	40, 40, 39, 81, 81, 122, 122, 121, 121, 123,
-	123, 89, 89, 89, 89, 89, 89, 105, 105, 41,
-	41, 97, 97, 68, 21, 99, 99, 42, 100, 100,
-	101, 101, 44, 43, 43, 32, 32, 32, 32, 32,
+	11, 11, 11, 11, 11, 11, 97, 97, 96, 96,
+	26, 26, 110, 110, 27, 12, 1, 1, 2, 2,
+	13, 13, 126, 126, 76, 76, 14, 15, 86, 86,
+	88, 88, 87, 87, 92, 92, 92, 92, 83, 83,
+	82, 82, 25, 25, 80, 80, 80, 80, 108, 108,
+	108, 8, 8, 84, 84, 67, 67, 65, 65, 69,
+	69, 66, 66, 119, 119, 120, 120, 29, 29, 30,
+	30, 75, 75, 73, 73, 73, 74, 74, 77, 77,
+	116, 116, 31, 31, 103, 103, 33, 107, 107, 34,
+	34, 121, 121, 35, 35, 35, 35, 125, 125, 79,
+	79, 79, 109, 109, 36, 36, 37, 38, 38, 38,
+	38, 40, 40, 39, 81, 81, 123, 123, 122, 122,
+	124, 124, 90, 90, 90, 90, 90, 90, 106, 106,
+	41, 41, 98, 98, 68, 21, 100, 100, 42, 101,
+	101, 102, 102, 44, 43, 43, 32, 32, 32, 32,
 	32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
 	32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
 	32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
@@ -1476,18 +1468,19 @@ var yyR1 = [...]int{
 	32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
 	32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
 	32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
-	32, 126, 3, 3, 88, 88, 111, 111, 51, 51,
-	52, 52, 52, 52, 45, 45, 46, 46, 49, 49,
-	93, 93, 93, 78, 78, 56, 56, 56, 50, 50,
-	50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
-	50, 50, 50, 50, 57, 57, 57, 23, 23, 24,
-	24, 55, 58, 58, 58, 59, 59, 59, 60, 60,
-	60, 60, 60, 60, 28, 28, 28, 47, 47, 47,
-	61, 61, 62, 62, 62, 62, 62, 62, 53, 53,
-	53, 54, 54, 54, 114, 71, 71, 113, 113, 70,
-	70, 70, 70, 70, 70, 92, 92, 92, 92, 63,
-	63, 63, 63, 63, 63, 63, 64, 64, 64, 64,
-	48, 48, 48, 48, 48, 48, 48, 112, 112, 72,
+	32, 32, 32, 85, 85, 127, 3, 3, 89, 89,
+	112, 112, 51, 51, 52, 52, 52, 52, 45, 45,
+	46, 46, 49, 49, 94, 94, 94, 78, 78, 56,
+	56, 56, 50, 50, 50, 50, 50, 50, 50, 50,
+	50, 50, 50, 50, 50, 50, 50, 50, 57, 57,
+	57, 23, 23, 24, 24, 55, 58, 58, 58, 59,
+	59, 59, 60, 60, 60, 60, 60, 60, 28, 28,
+	28, 47, 47, 47, 61, 61, 62, 62, 62, 62,
+	62, 62, 53, 53, 53, 54, 54, 54, 115, 71,
+	71, 114, 114, 70, 70, 70, 70, 70, 70, 93,
+	93, 93, 93, 63, 63, 63, 63, 63, 63, 63,
+	64, 64, 64, 64, 48, 48, 48, 48, 48, 48,
+	48, 113, 113, 72,
 }
 var yyR2 = [...]int{
 
@@ -1498,242 +1491,243 @@ var yyR2 = [...]int{
 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-	1, 1, 1, 1, 1, 1, 1, 1, 2, 0,
-	1, 3, 1, 3, 2, 1, 1, 1, 1, 1,
-	1, 4, 3, 5, 4, 3, 4, 3, 4, 3,
-	1, 1, 6, 7, 6, 7, 0, 1, 3, 1,
-	3, 1, 3, 1, 1, 2, 1, 3, 1, 2,
-	3, 1, 2, 0, 1, 1, 1, 1, 1, 1,
-	4, 3, 1, 1, 5, 7, 9, 5, 3, 3,
-	3, 3, 3, 3, 1, 2, 6, 7, 9, 5,
-	1, 6, 3, 3, 2, 0, 9, 1, 3, 0,
-	4, 1, 3, 1, 11, 0, 1, 0, 1, 9,
-	8, 1, 2, 1, 1, 6, 7, 0, 2, 0,
-	2, 0, 2, 1, 2, 4, 3, 1, 4, 1,
-	4, 1, 4, 3, 4, 4, 5, 0, 5, 4,
-	1, 1, 1, 4, 5, 6, 1, 3, 6, 7,
-	3, 6, 1, 0, 1, 3, 4, 6, 0, 1,
-	1, 2, 1, 1, 1, 0, 2, 2, 4, 1,
-	3, 1, 2, 3, 1, 1, 3, 1, 1, 3,
-	2, 0, 3, 4, 3, 10, 1, 3, 1, 2,
-	3, 1, 2, 2, 2, 3, 3, 3, 4, 3,
-	1, 1, 3, 1, 3, 1, 1, 0, 1, 1,
-	2, 1, 1, 1, 1, 1, 1, 3, 1, 2,
-	4, 3, 1, 4, 4, 3, 1, 1, 0, 1,
-	3, 1, 8, 3, 2, 6, 5, 3, 4, 2,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
+	0, 1, 3, 1, 3, 2, 1, 1, 1, 1,
+	1, 1, 4, 3, 5, 4, 3, 4, 3, 4,
+	3, 1, 1, 6, 7, 6, 7, 0, 1, 3,
+	1, 3, 1, 3, 1, 1, 2, 1, 3, 1,
+	2, 3, 1, 2, 0, 1, 1, 1, 1, 1,
+	1, 4, 3, 1, 1, 5, 7, 9, 5, 3,
+	3, 3, 3, 3, 3, 1, 2, 6, 7, 9,
+	5, 1, 6, 3, 3, 2, 0, 9, 1, 3,
+	0, 4, 1, 3, 1, 11, 0, 1, 0, 1,
+	9, 8, 1, 2, 1, 1, 6, 7, 0, 2,
+	0, 2, 0, 2, 1, 2, 4, 3, 1, 4,
+	1, 4, 1, 4, 3, 4, 4, 5, 0, 5,
+	4, 1, 1, 1, 4, 5, 6, 1, 3, 6,
+	7, 3, 6, 1, 0, 1, 3, 4, 6, 0,
+	1, 1, 2, 1, 1, 1, 0, 2, 2, 4,
+	1, 3, 1, 2, 3, 1, 1, 3, 1, 1,
+	3, 2, 0, 3, 4, 3, 10, 1, 3, 1,
+	2, 3, 1, 2, 2, 2, 3, 3, 3, 4,
+	3, 1, 1, 3, 1, 3, 1, 1, 0, 1,
+	1, 2, 1, 1, 1, 1, 1, 1, 3, 1,
+	2, 4, 3, 1, 4, 4, 3, 1, 1, 0,
+	1, 3, 1, 8, 3, 2, 6, 5, 3, 4,
+	2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+	3, 3, 3, 3, 2, 2, 2, 2, 3, 3,
 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 2, 2, 2, 2, 3, 3, 3, 3,
+	3, 3, 3, 3, 3, 2, 2, 2, 2, 3,
 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 2, 2, 2, 2, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 1, 5,
-	4, 3, 1, 2, 2, 2, 2, 2, 2, 2,
-	2, 2, 1, 3, 2, 1, 2, 4, 2, 11,
-	12, 0, 0, 1, 0, 4, 3, 1, 1, 2,
-	2, 4, 4, 2, 1, 1, 1, 1, 0, 3,
-	0, 1, 1, 0, 1, 4, 3, 1, 1, 1,
-	1, 1, 1, 1, 1, 1, 1, 1, 3, 2,
-	3, 3, 1, 1, 1, 3, 3, 1, 1, 0,
-	1, 1, 1, 3, 1, 1, 3, 1, 1, 4,
-	4, 4, 4, 1, 1, 1, 3, 1, 4, 2,
-	3, 3, 1, 4, 4, 3, 3, 3, 1, 3,
-	1, 1, 3, 1, 1, 0, 1, 3, 1, 3,
-	1, 4, 2, 6, 4, 2, 2, 1, 2, 1,
-	4, 3, 3, 3, 6, 3, 1, 1, 2, 1,
-	5, 4, 2, 2, 4, 2, 2, 1, 3, 1,
+	1, 5, 4, 3, 1, 2, 2, 2, 2, 2,
+	2, 2, 2, 2, 1, 3, 2, 1, 2, 4,
+	2, 1, 2, 11, 9, 0, 0, 1, 0, 4,
+	3, 1, 1, 2, 2, 4, 4, 2, 1, 1,
+	1, 1, 0, 3, 0, 1, 1, 0, 1, 4,
+	3, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 3, 2, 3, 3, 1, 1, 1, 3,
+	3, 1, 1, 0, 1, 1, 1, 3, 1, 1,
+	3, 1, 1, 4, 4, 4, 4, 1, 1, 1,
+	3, 1, 4, 2, 3, 3, 1, 4, 4, 3,
+	3, 3, 1, 3, 1, 1, 3, 1, 1, 0,
+	1, 3, 1, 3, 1, 4, 2, 6, 4, 2,
+	2, 1, 2, 1, 4, 3, 3, 3, 6, 3,
+	1, 1, 2, 1, 5, 4, 2, 2, 4, 2,
+	2, 1, 3, 1,
 }
 var yyChk = [...]int{
 
-	-1000, -127, -116, -9, 2, -11, -12, -13, -14, -15,
+	-1000, -128, -117, -9, 2, -11, -12, -13, -14, -15,
 	52, 80, 45, 39, 144, -65, -66, 21, 20, 23,
 	30, 34, 35, 40, 47, 99, 19, 14, -23, 49,
-	25, 27, 146, 41, 44, 36, 10, 37, -125, 53,
+	25, 27, 146, 41, 44, 36, 10, 37, -126, 53,
 	54, 55, -67, -69, -28, -32, -76, 7, -60, -61,
 	-58, 60, 150, 93, 105, 106, 155, 154, 156, 157,
 	148, -43, -48, 108, 109, 110, 111, 112, 113, 114,
-	6, 158, -50, 143, 97, 98, 107, 100, 101, -47,
-	-57, -52, -45, -55, -56, 92, 50, 51, 4, 5,
-	85, 86, 87, 8, 9, 67, 68, 82, 64, 65,
-	66, 81, 63, 75, 142, 12, 159, -10, -59, 61,
-	18, -94, 83, 148, 83, -94, 144, 10, -18, -90,
-	-110, -94, 83, 37, 39, -19, -20, -98, -21, 10,
-	-117, 148, -11, 37, 80, 148, 148, -24, -23, 99,
-	-24, -24, -102, -33, -47, -106, 37, -34, 12, -99,
-	-42, -23, 146, 131, 132, 88, 90, 89, 161, 153,
-	163, 169, 155, 154, 164, 133, 165, 166, 134, 135,
-	136, 137, 138, 139, 167, 140, 168, 141, 116, 91,
-	152, 115, 148, 148, 148, 144, -23, 10, 147, -3,
-	153, 53, -76, 10, 10, 10, 94, 95, 94, 96,
-	95, 162, 118, 119, 120, 121, 122, 123, 124, 125,
-	126, 127, 128, 129, 105, 106, 148, 150, 144, 58,
-	148, -114, -113, -71, -70, -23, 153, 60, -23, -28,
-	-57, 148, -56, 99, 150, -28, -23, -23, -23, -23,
-	-23, -23, -23, -23, -23, -23, -23, -23, -49, 148,
-	-23, -93, 17, -92, -63, 12, 77, 78, -23, -23,
-	-23, 150, 79, 79, -46, -44, -45, -62, 53, -10,
-	-47, 148, 148, -23, -23, 148, -23, -23, 17, 76,
-	-92, -92, 17, 144, -47, -77, 148, -77, 148, 83,
-	-94, 149, -94, 146, 144, -116, 146, -16, -110, -94,
-	83, 146, 160, 83, 29, -94, -20, 146, 160, 162,
-	-22, 145, 2, -11, -12, -13, -14, -15, 52, -23,
-	21, -3, -100, -101, -23, -23, 146, 146, 146, 146,
-	160, 146, 160, -3, 162, 146, 160, -23, -23, -23,
+	6, 158, -50, 143, 97, 98, 107, -85, 100, 101,
+	-47, -57, -52, -45, -55, -56, 92, 50, 51, 4,
+	5, 85, 86, 87, 8, 9, 67, 68, 82, 64,
+	65, 66, 81, 63, 75, 142, 38, 12, 159, -10,
+	-59, 61, 18, -95, 83, 148, 83, -95, 144, 10,
+	-18, -91, -111, -95, 83, 37, 39, -19, -20, -99,
+	-21, 10, -118, 148, -11, 37, 80, 148, 148, -24,
+	-23, 99, -24, -24, -103, -33, -47, -107, -85, -34,
+	12, -100, -42, -23, 146, 131, 132, 88, 90, 89,
+	161, 153, 163, 169, 155, 154, 164, 133, 165, 166,
+	134, 135, 136, 137, 138, 139, 167, 140, 168, 141,
+	116, 91, 152, 115, 148, 148, 148, 144, -23, 10,
+	147, -3, 153, 53, -76, 10, 10, 10, 94, 95,
+	94, 96, 95, 162, 118, 119, 120, 121, 122, 123,
+	124, 125, 126, 127, 128, 129, 130, 105, 106, 148,
+	150, 144, 58, 148, -115, -114, -71, -70, -23, 153,
+	60, -23, -28, -57, 148, -56, 99, 150, -28, -23,
+	-23, -23, -23, -23, -23, -23, -23, -23, -23, -23,
+	-23, -49, 148, -23, -94, 17, -93, -63, 12, 77,
+	78, -23, -23, -23, 150, 79, 79, -46, -44, -45,
+	-62, 53, -10, -47, 148, 148, -23, -23, 148, -23,
+	-23, 17, 76, -93, -93, 17, -3, 144, -47, -77,
+	148, -77, 148, 83, -95, 149, -95, 146, 144, -117,
+	146, -16, -111, -95, 83, 146, 160, 83, 29, -95,
+	-20, 146, 160, 162, -22, 145, 2, -11, -12, -13,
+	-14, -15, 52, -23, 21, -3, -101, -102, -23, -23,
+	146, 146, 146, 146, 160, 146, 160, 162, 146, 160,
 	-23, -23, -23, -23, -23, -23, -23, -23, -23, -23,
 	-23, -23, -23, -23, -23, -23, -23, -23, -23, -23,
-	-23, -23, -23, -46, -23, 147, -23, -109, -27, -28,
-	-23, -98, -117, 146, 146, 10, -126, 10, -85, 56,
-	-126, -87, 56, 148, -11, 148, 146, 147, -23, 153,
-	-23, -23, -23, -23, -23, -23, -23, -23, -23, -23,
-	-23, -23, -23, -24, -23, -54, 10, 144, -47, -114,
-	151, 160, 59, -28, 148, -23, -114, 149, -24, 143,
-	-63, -63, 17, 150, 58, -23, 11, -28, 59, -24,
-	-53, -6, -47, 144, 10, -5, -4, 99, 100, 101,
-	102, 103, 104, 4, 5, 85, 86, 87, 88, 89,
-	90, 91, 92, 93, 6, 7, 94, 95, 96, 19,
-	20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
-	41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
-	51, 35, 36, 37, 39, 40, 97, 98, 60, 30,
-	31, 32, 33, 34, 61, 62, 56, 57, 80, 54,
-	55, 53, 63, 64, 66, 65, 67, 68, 82, 81,
-	-53, -6, -47, -78, -77, 79, 150, 144, 58, 79,
-	-78, -112, -72, -23, -23, -23, 76, 76, 142, -23,
-	149, -115, -31, -23, 84, -114, 10, 146, -116, 145,
-	146, 146, 83, -94, -19, 83, -94, 144, 10, 83,
-	-21, -23, 148, 149, 148, 146, 160, 149, -33, -34,
-	-126, -23, -42, 147, -23, -7, 160, 29, 149, 145,
-	-126, 148, -85, -86, 57, -10, 144, -126, -124, -10,
-	-23, -23, -117, -23, 149, 151, 145, -77, -23, 149,
-	162, -71, -23, 153, 60, -114, 149, 151, 149, -64,
-	10, 13, 154, 12, 10, 145, 145, 150, 145, -23,
-	151, -77, -23, -77, -47, -24, -23, -54, -47, -85,
-	-7, 160, 149, 149, 145, -7, 160, -23, 149, 145,
-	144, 83, -104, -17, -20, -90, 144, -126, 149, -84,
-	-11, 147, -23, -100, -23, -80, 144, 147, 148, -23,
-	149, -27, -91, -28, 153, 60, 150, -25, -11, 147,
-	-96, 148, -118, -119, -29, -30, -75, -73, 152, 61,
-	62, -10, -86, -126, -124, -120, 144, 160, 149, 149,
-	96, -11, 147, 145, 162, -23, -28, 148, 149, 151,
-	13, -23, 145, 151, 145, -86, 149, -72, 149, -31,
-	-103, -20, 144, -7, 160, -20, -104, 146, -117, 149,
-	146, -107, 146, -107, 146, -118, 146, 149, 59, -28,
-	148, -114, -117, -26, 42, 43, -118, 149, 160, -1,
-	153, -73, -126, 144, 145, -35, -122, -121, 45, -123,
-	48, -89, 104, 103, 102, 99, 100, 101, -120, -10,
-	-11, 147, 146, -117, -23, -114, 151, -126, -7, 160,
-	-103, 145, -17, -7, 22, 146, -100, 145, 32, 33,
-	-107, 31, -107, 149, -82, -11, 147, -91, -28, -114,
-	151, 28, 148, 144, 149, -88, 45, -29, -2, 84,
-	144, -120, -105, -41, 12, 39, 37, -124, -89, 145,
-	-117, 149, 145, 144, 145, -20, -7, 145, 146, 149,
-	-23, -8, 147, 146, 145, 146, 31, -88, -117, 149,
-	149, 146, -95, -10, -117, -74, 147, -74, 148, 12,
-	-120, 145, 146, 160, -126, 162, -97, -68, -6, -3,
-	-79, 146, 144, -120, 145, -83, -11, 147, -8, -117,
-	146, -74, 26, -82, 12, 161, 145, 144, -75, 144,
-	-111, -51, 12, 153, 162, 145, -41, -23, 146, 160,
-	162, -6, 145, -108, -36, -37, -38, -39, -40, -10,
-	-6, 80, 10, 145, -117, -117, 144, 146, 149, -10,
-	-117, -117, 149, 160, 12, -23, -126, -68, -23, -126,
-	145, -36, 146, 146, 46, 29, 79, 24, -117, 144,
-	145, 145, -51, -126, 148, -124, 10, -4, -89, -6,
-	146, 145, -117, -118, -6, 145, 149, -74, -81, 146,
-	144, -117, 145,
+	-23, -23, -23, -23, -23, -23, -46, -23, 147, -23,
+	-110, -27, -28, -23, -99, -118, 146, 146, 10, -127,
+	10, -86, 56, -127, -88, 56, 148, -11, 148, 146,
+	147, -23, 153, -23, -23, -23, -23, -23, -23, -23,
+	-23, -23, -23, -23, -23, -23, -23, -24, -23, -54,
+	10, 144, -47, -115, 151, 160, 59, -28, 148, -23,
+	-115, 149, -24, 143, -63, -63, 17, 150, 58, -23,
+	11, -28, 59, -24, -53, -6, -47, 144, 10, -5,
+	-4, 99, 100, 101, 102, 103, 104, 4, 5, 85,
+	86, 87, 88, 89, 90, 91, 92, 93, 6, 7,
+	94, 95, 96, 19, 20, 21, 22, 23, 24, 25,
+	26, 27, 28, 29, 41, 42, 43, 44, 45, 46,
+	47, 48, 49, 50, 51, 35, 36, 37, 39, 40,
+	97, 98, 60, 30, 31, 32, 33, 34, 61, 62,
+	56, 57, 80, 54, 55, 53, 63, 64, 66, 65,
+	67, 68, 82, 81, 38, -53, -6, -47, -78, -77,
+	79, 150, 144, 58, 79, -78, -113, -72, -23, -23,
+	-23, 76, 76, 142, 148, -23, 149, -116, -31, -23,
+	84, -115, 10, 146, -117, 145, 146, 146, 83, -95,
+	-19, 83, -95, 144, 10, 83, -21, -23, 148, 149,
+	148, 146, 160, 149, -33, -34, -23, -42, 147, -23,
+	-7, 160, 29, 149, 145, -127, 148, -86, -87, 57,
+	-10, 144, -127, -125, -10, -23, -23, -118, -23, 149,
+	151, 145, -77, -23, 149, 162, -71, -23, 153, 60,
+	-115, 149, 151, 149, -64, 10, 13, 154, 12, 10,
+	145, 145, 150, 145, -23, 151, -77, -23, -77, -47,
+	-24, -23, -54, -47, -86, -7, 160, 149, 149, -119,
+	-120, -29, -30, -75, -73, 152, 61, 62, -10, 145,
+	-7, 160, -23, 149, 145, 144, 83, -105, -17, -20,
+	-91, 144, -127, 149, -84, -11, 147, -23, -101, -23,
+	-80, 144, 147, -23, 149, -27, -92, -28, 153, 60,
+	150, -25, -11, 147, -97, 148, -119, -87, -127, -125,
+	-121, 144, 160, 149, 149, 96, -11, 147, 145, 162,
+	-23, -28, 148, 149, 151, 13, -23, 145, 151, 145,
+	-87, 149, -72, 149, 160, -1, 153, -73, 149, -31,
+	-104, -20, 144, -7, 160, -20, -105, 146, -118, 149,
+	146, -108, 146, -108, 146, 146, 149, 59, -28, 148,
+	-115, -118, -26, 42, 43, -119, 149, -127, 144, 145,
+	-35, -123, -122, 45, -124, 48, -90, 104, 103, 102,
+	99, 100, 101, -121, -10, -11, 147, 146, -118, -23,
+	-115, 151, -127, -74, 147, -29, -2, 84, -7, 160,
+	-104, 145, -17, -7, 22, 146, -101, 145, 32, 33,
+	-108, 31, -108, -82, -11, 147, -92, -28, -115, 151,
+	28, 148, 144, 149, -89, 45, 144, -121, -106, -41,
+	12, 39, 37, -125, -90, 145, -118, 149, 145, 144,
+	-127, -75, 12, 145, -20, -7, 145, 146, 149, -23,
+	-8, 147, 146, 145, 146, 31, -118, 149, 149, 146,
+	-96, -10, -118, -74, -74, 148, -121, 145, 146, 160,
+	-127, 162, -98, -68, -6, -3, -79, 146, 144, -121,
+	59, 162, 145, -83, -11, 147, -8, -118, 146, 26,
+	-82, 12, 161, 145, 144, 144, -112, -51, 12, 153,
+	145, -41, -23, 146, 160, 162, -6, 145, -109, -36,
+	-37, -38, -39, -40, -10, -6, 80, 10, 145, -23,
+	-23, -118, -118, 146, 149, -10, -118, -118, 149, 160,
+	12, -127, -68, -23, -127, 145, -36, 146, 146, 46,
+	29, 79, 24, 144, 145, 145, -51, -127, 148, -125,
+	10, -4, -90, -6, 146, -118, -119, -6, 145, 149,
+	-74, -81, 146, 144, -118, 145,
 }
 var yyDef = [...]int{
 
-	79, -2, -2, 78, 85, 86, 87, 88, 89, 90,
-	0, 0, 0, 0, 123, 132, 133, 0, 0, 0,
-	0, 419, 419, 419, 0, 384, 0, 144, 0, 0,
-	0, 0, 150, 0, 0, 0, 80, 372, 0, 0,
-	0, 0, 206, 0, -2, 418, 171, 0, -2, 435,
-	421, 0, 455, 0, 0, 0, 0, 0, 0, 0,
-	0, 348, 352, 0, 0, 0, 0, 0, 0, 0,
-	388, 0, 362, 390, 0, 365, 0, 173, 174, 428,
-	413, 433, 0, 0, -2, 0, 0, 0, 0, 0,
-	0, 0, 0, 398, 399, 400, 401, 402, 403, 404,
-	405, 406, 407, 0, 0, 437, 0, -2, 0, 0,
-	397, 82, 0, 0, 0, 0, 79, 80, 0, 0,
-	0, 116, 0, 100, 101, 113, 118, 0, 121, 0,
-	0, 0, 0, 372, 0, 288, 0, 0, 420, 384,
-	0, 0, 0, 234, 235, 0, 372, 237, 238, 0,
-	286, 287, 145, 0, 0, 0, 0, 0, 0, 0,
+	80, -2, -2, 79, 86, 87, 88, 89, 90, 91,
+	0, 0, 0, 0, 124, 133, 134, 0, 0, 0,
+	0, 423, 423, 423, 0, 388, 0, 145, 0, 0,
+	0, 0, 151, 0, 0, 0, 81, 376, 0, 0,
+	0, 0, 207, 0, -2, 422, 172, 0, -2, 439,
+	425, 0, 459, 0, 0, 0, 0, 0, 0, 0,
+	0, 350, 354, 0, 0, 0, 0, 0, 0, 0,
+	392, 0, 364, 394, 0, 367, 0, 371, 174, 175,
+	432, 417, 437, 0, 0, -2, 0, 0, 0, 0,
+	0, 0, 0, 0, 402, 403, 404, 405, 406, 407,
+	408, 409, 410, 411, 0, 0, 376, 441, 0, -2,
+	0, 0, 401, 83, 0, 0, 0, 0, 80, 81,
+	0, 0, 0, 117, 0, 101, 102, 114, 119, 0,
+	122, 0, 0, 0, 0, 376, 0, 289, 0, 0,
+	424, 388, 0, 0, 0, 235, 236, 0, 372, 238,
+	239, 0, 287, 288, 146, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 123, 0, 0, 154, 371,
-	373, 0, 172, 177, 371, 179, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 124, 0, 0,
+	155, 375, 377, 0, 173, 178, 375, 180, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 312, 314, 0, 419, 0, 0,
-	455, 0, 454, 458, 456, 460, 0, 0, 299, -2,
-	0, 0, -2, 384, 455, -2, 333, 334, 335, 336,
-	0, 353, 354, 355, 356, 357, 358, 359, 360, 419,
-	361, 0, 391, 392, 467, 469, 0, 0, 364, 366,
-	368, 419, 0, 0, 393, 294, 386, 387, 393, 385,
-	442, 0, 0, 482, 483, 0, 485, 486, 0, 409,
-	0, 0, 0, 0, 439, 380, 0, 383, 455, 0,
-	84, 0, 83, 92, 79, 0, 95, 0, 0, 116,
-	0, 97, 0, 0, 0, 116, 119, 99, 0, 0,
-	122, 131, 124, 125, 126, 127, 128, 129, 0, 0,
-	0, 371, 0, 289, 291, 0, 138, 139, 140, 141,
-	0, 142, 0, 371, 0, 143, 0, 316, 317, 318,
-	319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
-	329, 330, 331, 332, -2, -2, -2, -2, -2, -2,
-	-2, -2, -2, 346, 0, 0, 351, 106, 161, -2,
-	0, 0, 0, 152, 153, 371, 0, 177, 181, 0,
-	0, 371, 0, 0, 207, 0, 210, 123, 297, 0,
-	300, 301, 302, 303, 304, 305, 306, 307, 308, 309,
-	310, 311, 0, 0, 0, 436, 451, 0, 453, 0,
-	396, 455, 0, -2, 455, 0, 0, -2, 0, 363,
-	468, 465, 466, 0, 0, 0, 0, 422, 0, 0,
-	0, -2, -2, 0, 76, 77, 69, 70, 71, 72,
-	73, 74, 75, 2, 3, 4, 5, 6, 7, 8,
-	9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
-	19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
-	29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
-	39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
-	49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
-	59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
-	0, -2, -2, 293, 394, 0, 419, 0, 0, 0,
-	177, 106, 487, 489, 0, 0, 408, 411, 410, 0,
-	227, 106, 229, 231, 0, 0, 81, 91, 0, 94,
-	96, 98, 0, 116, 112, 0, 116, 0, 117, 0,
-	120, 371, 0, 0, 0, 288, 0, 0, 233, 236,
-	0, 239, 285, 0, 350, 0, 107, 0, 0, 155,
-	0, -2, 181, 371, 0, 178, 241, 0, 180, 246,
-	0, 0, 0, 298, 0, 429, 431, 432, 0, 0,
-	0, 457, 459, 0, 0, 0, -2, 396, 389, 0,
-	476, 477, 0, 479, 471, 472, 473, 0, 475, 367,
-	430, 381, 0, 382, 446, 0, 0, 445, 447, 181,
-	0, 107, 481, 484, 438, 0, 107, 232, 395, 93,
-	0, 0, 106, 109, 114, 0, 0, 284, 0, 134,
-	202, 123, 0, 0, 290, 137, 197, 197, -2, 349,
-	0, 162, 0, -2, 0, 0, 455, 149, 191, 123,
-	159, -2, 0, 212, 214, 165, 219, 220, 0, 222,
-	223, 224, 371, 0, 182, 267, 241, 0, 0, 0,
-	0, 204, 123, 452, 0, 296, -2, 455, 464, 470,
-	478, 0, 449, 443, 444, 371, 480, 488, 228, 230,
-	106, 111, 0, 0, 107, 115, 106, 130, 0, 0,
-	288, 0, 197, 0, 197, 0, 146, 0, 0, -2,
-	455, 0, 0, 151, 0, 0, 0, 374, 218, 167,
-	166, 221, 0, 241, 175, 240, 0, 0, 0, -2,
-	266, 269, 271, 272, 273, 274, 275, 276, 267, 247,
-	205, 123, 211, -2, 295, 0, 0, 0, 0, 107,
-	106, 104, 108, 0, 0, 135, 0, 193, 0, 0,
-	0, 0, 0, 374, 147, 189, 123, 0, -2, 0,
-	-2, 0, 0, 123, 225, 225, 0, 215, 0, 168,
-	241, 267, 0, 278, 371, 0, 372, 0, 270, 176,
-	-2, 463, 474, 241, 102, 110, 0, 105, 203, 0,
-	0, 123, 200, 201, 194, 195, 0, 225, 0, 0,
-	185, 192, 0, 157, 0, 0, 0, 0, 0, 216,
-	267, 170, 242, 0, 279, 0, 0, 282, 0, 0,
-	244, 248, 0, 267, 103, 136, 187, 123, 123, -2,
-	196, 0, 0, 148, 0, 0, 160, 123, 226, 123,
-	0, 377, 378, 0, 0, 169, 277, 371, 243, 0,
-	0, 371, 249, 0, 251, 0, 0, 261, 0, 0,
-	260, 57, -2, 292, 0, -2, 123, 190, 0, 158,
-	0, 0, 375, 0, 379, 217, 280, 281, 371, 0,
-	250, 252, 253, 254, 0, 0, 0, 0, 0, 123,
-	164, 369, 376, 283, -2, 255, 256, 257, 259, 262,
-	188, 370, 0, 0, 258, 156, 225, 0, 245, 263,
-	123, 0, 264,
+	0, 0, 0, 0, 0, 0, 0, 314, 316, 0,
+	423, 0, 0, 459, 0, 458, 462, 460, 464, 0,
+	0, 300, -2, 0, 0, -2, 388, 459, -2, 335,
+	336, 337, 338, 0, 355, 356, 357, 358, 359, 360,
+	361, 362, 423, 363, 0, 395, 396, 471, 473, 0,
+	0, 366, 368, 370, 423, 0, 0, 397, 295, 390,
+	391, 397, 389, 446, 0, 0, 486, 487, 0, 489,
+	490, 0, 413, 0, 0, 0, 0, 0, 443, 384,
+	0, 387, 459, 0, 85, 0, 84, 93, 80, 0,
+	96, 0, 0, 117, 0, 98, 0, 0, 0, 117,
+	120, 100, 0, 0, 123, 132, 125, 126, 127, 128,
+	129, 130, 0, 0, 0, 375, 0, 290, 292, 0,
+	139, 140, 141, 142, 0, 143, 0, 0, 144, 0,
+	318, 319, 320, 321, 322, 323, 324, 325, 326, 327,
+	328, 329, 330, 331, 332, 333, 334, -2, -2, -2,
+	-2, -2, -2, -2, -2, -2, 348, 0, 0, 353,
+	107, 162, -2, 0, 0, 0, 153, 154, 375, 0,
+	178, 182, 0, 0, 375, 0, 0, 208, 0, 211,
+	124, 298, 0, 301, 302, 303, 304, 305, 306, 307,
+	308, 309, 310, 311, 312, 313, 0, 0, 0, 440,
+	455, 0, 457, 0, 400, 459, 0, -2, 459, 0,
+	0, -2, 0, 365, 472, 469, 470, 0, 0, 0,
+	0, 426, 0, 0, 0, -2, -2, 0, 77, 78,
+	70, 71, 72, 73, 74, 75, 76, 2, 3, 4,
+	5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+	15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+	25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+	35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
+	45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
+	55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
+	65, 66, 67, 68, 69, 0, -2, -2, 294, 398,
+	0, 423, 0, 0, 0, 178, 107, 491, 493, 0,
+	0, 412, 415, 414, -2, 0, 228, 107, 230, 232,
+	0, 0, 82, 92, 0, 95, 97, 99, 0, 117,
+	113, 0, 117, 0, 118, 0, 121, 375, 0, 0,
+	0, 289, 0, 0, 234, 237, 240, 286, 0, 352,
+	0, 108, 0, 0, 156, 0, -2, 182, 375, 0,
+	179, 242, 0, 181, 247, 0, 0, 0, 299, 0,
+	433, 435, 436, 0, 0, 0, 461, 463, 0, 0,
+	0, -2, 400, 393, 0, 480, 481, 0, 483, 475,
+	476, 477, 0, 479, 369, 434, 385, 0, 386, 450,
+	0, 0, 449, 451, 182, 0, 108, 485, 488, 0,
+	213, 215, 166, 220, 221, 0, 223, 224, 225, 442,
+	0, 108, 233, 399, 94, 0, 0, 107, 110, 115,
+	0, 0, 285, 0, 135, 203, 124, 0, 0, 291,
+	138, 198, 198, 351, 0, 163, 0, -2, 0, 0,
+	459, 150, 192, 124, 160, -2, 0, 375, 0, 183,
+	268, 242, 0, 0, 0, 0, 205, 124, 456, 0,
+	297, -2, 459, 468, 474, 482, 0, 453, 447, 448,
+	375, 484, 492, 226, 219, 168, 167, 222, 229, 231,
+	107, 112, 0, 0, 108, 116, 107, 131, 0, 0,
+	289, 0, 198, 0, 198, 147, 0, 0, -2, 459,
+	0, 0, 152, 0, 0, 0, 378, 0, 242, 176,
+	241, 0, 0, 0, -2, 267, 270, 272, 273, 274,
+	275, 276, 277, 268, 248, 206, 124, 212, -2, 296,
+	0, 0, 0, 375, 0, 216, 0, 169, 0, 108,
+	107, 105, 109, 0, 0, 136, 0, 194, 0, 0,
+	0, 0, 0, 148, 190, 124, 0, -2, 0, -2,
+	0, 0, 124, 226, 226, 0, 242, 268, 0, 279,
+	375, 0, 376, 0, 271, 177, -2, 467, 478, 242,
+	0, 227, 217, 103, 111, 0, 106, 204, 0, 0,
+	124, 201, 202, 195, 196, 0, 0, 0, 186, 193,
+	0, 158, 0, 0, 0, 0, 268, 171, 243, 0,
+	280, 0, 0, 283, 0, 0, 245, 249, 0, 268,
+	0, 0, 104, 137, 188, 124, 124, -2, 197, 0,
+	149, 0, 0, 161, 124, 124, 0, 381, 382, 0,
+	170, 278, 375, 244, 0, 0, 375, 250, 0, 252,
+	0, 0, 262, 0, 0, 261, 57, -2, 293, 374,
+	218, 0, -2, 191, 0, 159, 0, 0, 379, 0,
+	383, 281, 282, 375, 0, 251, 253, 254, 255, 0,
+	0, 0, 0, 124, 165, 373, 380, 284, -2, 256,
+	257, 258, 260, 263, 189, 0, 0, 259, 157, 226,
+	0, 246, 264, 124, 0, 265,
 }
 var yyTok1 = [...]int{
 
@@ -2111,7 +2105,7 @@ yydefault:
 
 	case 1:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:302
+		//line php7/php7.y:303
 		{
 			yylex.(*Parser).rootNode = node.NewRoot(yyDollar[1].list)
 
@@ -2124,463 +2118,469 @@ yydefault:
 		}
 	case 2:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:315
+		//line php7/php7.y:316
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 3:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:315
+		//line php7/php7.y:316
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 4:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:315
+		//line php7/php7.y:316
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 5:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:315
+		//line php7/php7.y:316
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 6:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:315
+		//line php7/php7.y:316
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 7:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:315
+		//line php7/php7.y:316
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 8:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:315
+		//line php7/php7.y:316
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 9:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:315
+		//line php7/php7.y:316
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 10:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 11:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 12:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 13:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 14:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 15:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 16:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 17:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 18:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 19:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 20:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 21:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:316
+		//line php7/php7.y:317
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 22:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:317
+		//line php7/php7.y:318
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 23:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:317
+		//line php7/php7.y:318
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 24:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:317
+		//line php7/php7.y:318
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 25:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:317
+		//line php7/php7.y:318
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 26:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:317
+		//line php7/php7.y:318
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 27:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:317
+		//line php7/php7.y:318
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 28:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:317
+		//line php7/php7.y:318
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 29:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:317
+		//line php7/php7.y:318
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 30:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:317
+		//line php7/php7.y:318
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 31:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:317
+		//line php7/php7.y:318
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 32:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:318
+		//line php7/php7.y:319
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 33:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:318
+		//line php7/php7.y:319
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 34:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:318
+		//line php7/php7.y:319
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 35:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:318
+		//line php7/php7.y:319
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 36:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:318
+		//line php7/php7.y:319
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 37:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:318
+		//line php7/php7.y:319
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 38:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:318
+		//line php7/php7.y:319
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 39:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:318
+		//line php7/php7.y:319
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 40:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:318
+		//line php7/php7.y:319
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 41:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:318
+		//line php7/php7.y:319
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 42:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:319
+		//line php7/php7.y:320
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 43:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:319
+		//line php7/php7.y:320
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 44:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:319
+		//line php7/php7.y:320
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 45:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:319
+		//line php7/php7.y:320
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 46:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:319
+		//line php7/php7.y:320
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 47:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:319
+		//line php7/php7.y:320
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 48:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:319
+		//line php7/php7.y:320
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 49:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:319
+		//line php7/php7.y:320
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 50:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:319
+		//line php7/php7.y:320
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 51:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:319
+		//line php7/php7.y:320
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 52:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:319
+		//line php7/php7.y:320
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 53:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:320
+		//line php7/php7.y:321
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 54:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:320
+		//line php7/php7.y:321
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 55:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:320
+		//line php7/php7.y:321
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 56:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:320
+		//line php7/php7.y:321
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 57:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:320
+		//line php7/php7.y:321
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 58:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:320
+		//line php7/php7.y:321
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 59:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:320
+		//line php7/php7.y:321
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 60:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:320
+		//line php7/php7.y:321
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 61:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:321
+		//line php7/php7.y:322
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 62:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:321
+		//line php7/php7.y:322
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 63:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:321
+		//line php7/php7.y:322
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 64:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:321
+		//line php7/php7.y:322
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 65:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:321
+		//line php7/php7.y:322
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 66:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:321
+		//line php7/php7.y:322
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 67:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:321
+		//line php7/php7.y:322
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 68:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:321
+		//line php7/php7.y:322
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 69:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:326
+		//line php7/php7.y:322
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 70:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:329
+		//line php7/php7.y:327
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 71:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:329
+		//line php7/php7.y:330
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 72:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:329
+		//line php7/php7.y:330
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 73:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:329
+		//line php7/php7.y:330
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 74:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:329
+		//line php7/php7.y:330
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 75:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:329
+		//line php7/php7.y:330
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 76:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:334
+		//line php7/php7.y:330
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 77:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:338
+		//line php7/php7.y:335
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 78:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:339
+		{
+			yyVAL.token = yyDollar[1].token
+		}
+	case 79:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:345
+		//line php7/php7.y:346
 		{
 			if inlineHtmlNode, ok := yyDollar[2].node.(*stmt.InlineHtml); ok && len(yyDollar[1].list) > 0 {
 				prevNode := lastNode(yyDollar[1].list)
@@ -2593,17 +2593,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 79:
+	case 80:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:358
+		//line php7/php7.y:359
 		{
 			yyVAL.list = []node.Node{}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 80:
+	case 81:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:367
+		//line php7/php7.y:368
 		{
 			namePart := name.NewNamePart(yyDollar[1].token.Value)
 			yyVAL.list = []node.Node{namePart}
@@ -2616,9 +2616,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 81:
+	case 82:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:380
+		//line php7/php7.y:381
 		{
 			namePart := name.NewNamePart(yyDollar[3].token.Value)
 			yyVAL.list = append(yyDollar[1].list, namePart)
@@ -2632,9 +2632,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 82:
+	case 83:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:397
+		//line php7/php7.y:398
 		{
 			yyVAL.node = name.NewName(yyDollar[1].list)
 
@@ -2646,9 +2646,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 83:
+	case 84:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:409
+		//line php7/php7.y:410
 		{
 			yyVAL.node = name.NewRelative(yyDollar[3].list)
 
@@ -2661,9 +2661,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 84:
+	case 85:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:422
+		//line php7/php7.y:423
 		{
 			yyVAL.node = name.NewFullyQualified(yyDollar[2].list)
 
@@ -2675,26 +2675,18 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 85:
+	case 86:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:437
+		//line php7/php7.y:438
 		{
 			// error
 			yyVAL.node = nil
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 86:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:444
-		{
-			yyVAL.node = yyDollar[1].node
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 87:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:450
+		//line php7/php7.y:445
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -2702,7 +2694,7 @@ yydefault:
 		}
 	case 88:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:456
+		//line php7/php7.y:451
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -2710,7 +2702,7 @@ yydefault:
 		}
 	case 89:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:462
+		//line php7/php7.y:457
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -2718,15 +2710,23 @@ yydefault:
 		}
 	case 90:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:468
+		//line php7/php7.y:463
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 91:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:469
+		{
+			yyVAL.node = yyDollar[1].node
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 92:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:474
+		//line php7/php7.y:475
 		{
 			yyVAL.node = stmt.NewHaltCompiler()
 
@@ -2742,9 +2742,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 92:
+	case 93:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:490
+		//line php7/php7.y:491
 		{
 			name := name.NewName(yyDollar[2].list)
 			yyVAL.node = stmt.NewNamespace(name, nil)
@@ -2761,9 +2761,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 93:
+	case 94:
 		yyDollar = yyS[yypt-5 : yypt+1]
-		//line php7/php7.y:507
+		//line php7/php7.y:508
 		{
 			name := name.NewName(yyDollar[2].list)
 			yyVAL.node = stmt.NewNamespace(name, yyDollar[4].list)
@@ -2780,9 +2780,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 94:
+	case 95:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:524
+		//line php7/php7.y:525
 		{
 			yyVAL.node = stmt.NewNamespace(nil, yyDollar[3].list)
 
@@ -2796,9 +2796,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 95:
+	case 96:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:538
+		//line php7/php7.y:539
 		{
 			yyVAL.node = yyDollar[2].node
 
@@ -2812,9 +2812,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 96:
+	case 97:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:552
+		//line php7/php7.y:553
 		{
 			yyVAL.node = yyDollar[3].node.(*stmt.GroupUse).SetUseType(yyDollar[2].node)
 
@@ -2828,9 +2828,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 97:
+	case 98:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:566
+		//line php7/php7.y:567
 		{
 			yyVAL.node = stmt.NewUseList(nil, yyDollar[2].list)
 
@@ -2844,9 +2844,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 98:
+	case 99:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:580
+		//line php7/php7.y:581
 		{
 			yyVAL.node = stmt.NewUseList(yyDollar[2].node, yyDollar[3].list)
 
@@ -2860,9 +2860,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 99:
+	case 100:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:594
+		//line php7/php7.y:595
 		{
 			yyVAL.node = stmt.NewConstList(yyDollar[2].list)
 
@@ -2874,25 +2874,11 @@ yydefault:
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Stmts, yyDollar[3].token.FreeFloating)
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.SemiColon, yylex.(*Parser).GetFreeFloatingToken(yyDollar[3].token))
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 100:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:611
-		{
-			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 101:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:623
+		//line php7/php7.y:612
 		{
 			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
 
@@ -2905,8 +2891,22 @@ yydefault:
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 102:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:624
+		{
+			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 103:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:638
+		//line php7/php7.y:639
 		{
 			name := name.NewName(yyDollar[1].list)
 			yyVAL.node = stmt.NewGroupUse(nil, name, yyDollar[4].list)
@@ -2927,9 +2927,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 103:
+	case 104:
 		yyDollar = yyS[yypt-7 : yypt+1]
-		//line php7/php7.y:659
+		//line php7/php7.y:660
 		{
 			name := name.NewName(yyDollar[2].list)
 			yyVAL.node = stmt.NewGroupUse(nil, name, yyDollar[5].list)
@@ -2951,9 +2951,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 104:
+	case 105:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:684
+		//line php7/php7.y:685
 		{
 			name := name.NewName(yyDollar[1].list)
 			yyVAL.node = stmt.NewGroupUse(nil, name, yyDollar[4].list)
@@ -2974,9 +2974,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 105:
+	case 106:
 		yyDollar = yyS[yypt-7 : yypt+1]
-		//line php7/php7.y:705
+		//line php7/php7.y:706
 		{
 			name := name.NewName(yyDollar[2].list)
 			yyVAL.node = stmt.NewGroupUse(nil, name, yyDollar[5].list)
@@ -2998,59 +2998,40 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 106:
+	case 107:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:730
+		//line php7/php7.y:731
 		{
 			yyVAL.token = nil
 		}
-	case 107:
+	case 108:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:734
+		//line php7/php7.y:735
 		{
 			yyVAL.token = yyDollar[1].token
 		}
-	case 108:
+	case 109:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:741
+		//line php7/php7.y:742
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
 			// save comments
 			yylex.(*Parser).setFreeFloating(lastNode(yyDollar[1].list), freefloating.End, yyDollar[2].token.FreeFloating)
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 109:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:750
-		{
-			yyVAL.list = []node.Node{yyDollar[1].node}
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 110:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:759
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:751
 		{
-			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(lastNode(yyDollar[1].list), freefloating.End, yyDollar[2].token.FreeFloating)
+			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 111:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:768
-		{
-			yyVAL.list = []node.Node{yyDollar[1].node}
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 112:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:777
+		//line php7/php7.y:760
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -3059,33 +3040,52 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 113:
+	case 112:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:786
+		//line php7/php7.y:769
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 113:
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line php7/php7.y:778
+		{
+			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(lastNode(yyDollar[1].list), freefloating.End, yyDollar[2].token.FreeFloating)
+
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 114:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:795
+		//line php7/php7.y:787
+		{
+			yyVAL.list = []node.Node{yyDollar[1].node}
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 115:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:796
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 115:
+	case 116:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:801
+		//line php7/php7.y:802
 		{
 			yyVAL.node = yyDollar[2].node.(*stmt.Use).SetUseType(yyDollar[1].node)
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 116:
+	case 117:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:810
+		//line php7/php7.y:811
 		{
 			name := name.NewName(yyDollar[1].list)
 			yyVAL.node = stmt.NewUse(nil, name, nil)
@@ -3099,9 +3099,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 117:
+	case 118:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:824
+		//line php7/php7.y:825
 		{
 			name := name.NewName(yyDollar[1].list)
 			alias := node.NewIdentifier(yyDollar[3].token.Value)
@@ -3119,9 +3119,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 118:
+	case 119:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:845
+		//line php7/php7.y:846
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -3130,9 +3130,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 119:
+	case 120:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:854
+		//line php7/php7.y:855
 		{
 			yyVAL.node = yyDollar[2].node
 
@@ -3145,9 +3145,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 120:
+	case 121:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:870
+		//line php7/php7.y:871
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -3156,17 +3156,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 121:
+	case 122:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:879
+		//line php7/php7.y:880
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 122:
+	case 123:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:888
+		//line php7/php7.y:889
 		{
 			if inlineHtmlNode, ok := yyDollar[2].node.(*stmt.InlineHtml); ok && len(yyDollar[1].list) > 0 {
 				prevNode := lastNode(yyDollar[1].list)
@@ -3179,34 +3179,26 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 123:
+	case 124:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:901
+		//line php7/php7.y:902
 		{
 			yyVAL.list = []node.Node{}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 124:
+	case 125:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:910
+		//line php7/php7.y:911
 		{
 			// error
 			yyVAL.node = nil
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 125:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:917
-		{
-			yyVAL.node = yyDollar[1].node
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 126:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:923
+		//line php7/php7.y:918
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -3214,7 +3206,7 @@ yydefault:
 		}
 	case 127:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:929
+		//line php7/php7.y:924
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -3222,7 +3214,7 @@ yydefault:
 		}
 	case 128:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:935
+		//line php7/php7.y:930
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -3230,15 +3222,23 @@ yydefault:
 		}
 	case 129:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:941
+		//line php7/php7.y:936
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 130:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:942
+		{
+			yyVAL.node = yyDollar[1].node
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 131:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:947
+		//line php7/php7.y:948
 		{
 			yyVAL.node = stmt.NewHaltCompiler()
 
@@ -3254,9 +3254,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 131:
+	case 132:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:965
+		//line php7/php7.y:966
 		{
 			yyVAL.node = stmt.NewStmtList(yyDollar[2].list)
 
@@ -3267,27 +3267,27 @@ yydefault:
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Stmts, yyDollar[3].token.FreeFloating)
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 132:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:978
-		{
-			yyVAL.node = yyDollar[1].node
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 133:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:984
+		//line php7/php7.y:979
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 134:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:985
+		{
+			yyVAL.node = yyDollar[1].node
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 135:
 		yyDollar = yyS[yypt-5 : yypt+1]
-		//line php7/php7.y:990
+		//line php7/php7.y:991
 		{
 			switch n := yyDollar[5].node.(type) {
 			case *stmt.While:
@@ -3308,9 +3308,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 135:
+	case 136:
 		yyDollar = yyS[yypt-7 : yypt+1]
-		//line php7/php7.y:1011
+		//line php7/php7.y:1012
 		{
 			yyVAL.node = stmt.NewDo(yyDollar[2].node, yyDollar[5].node)
 
@@ -3327,9 +3327,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 136:
+	case 137:
 		yyDollar = yyS[yypt-9 : yypt+1]
-		//line php7/php7.y:1028
+		//line php7/php7.y:1029
 		{
 			switch n := yyDollar[9].node.(type) {
 			case *stmt.For:
@@ -3356,9 +3356,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 137:
+	case 138:
 		yyDollar = yyS[yypt-5 : yypt+1]
-		//line php7/php7.y:1055
+		//line php7/php7.y:1056
 		{
 			switch n := yyDollar[5].node.(type) {
 			case *stmt.Switch:
@@ -3381,9 +3381,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 138:
+	case 139:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1078
+		//line php7/php7.y:1079
 		{
 			yyVAL.node = stmt.NewBreak(yyDollar[2].node)
 
@@ -3397,9 +3397,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 139:
+	case 140:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1092
+		//line php7/php7.y:1093
 		{
 			yyVAL.node = stmt.NewContinue(yyDollar[2].node)
 
@@ -3413,9 +3413,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 140:
+	case 141:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1106
+		//line php7/php7.y:1107
 		{
 			yyVAL.node = stmt.NewReturn(yyDollar[2].node)
 
@@ -3429,9 +3429,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 141:
+	case 142:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1120
+		//line php7/php7.y:1121
 		{
 			yyVAL.node = stmt.NewGlobal(yyDollar[2].list)
 
@@ -3445,9 +3445,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 142:
+	case 143:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1134
+		//line php7/php7.y:1135
 		{
 			yyVAL.node = stmt.NewStatic(yyDollar[2].list)
 
@@ -3461,9 +3461,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 143:
+	case 144:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1148
+		//line php7/php7.y:1149
 		{
 			yyVAL.node = stmt.NewEcho(yyDollar[2].list)
 
@@ -3478,9 +3478,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 144:
+	case 145:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1163
+		//line php7/php7.y:1164
 		{
 			yyVAL.node = stmt.NewInlineHtml(yyDollar[1].token.Value)
 
@@ -3492,9 +3492,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 145:
+	case 146:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:1175
+		//line php7/php7.y:1176
 		{
 			yyVAL.node = stmt.NewExpression(yyDollar[1].node)
 
@@ -3508,9 +3508,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 146:
+	case 147:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:1189
+		//line php7/php7.y:1190
 		{
 			yyVAL.node = stmt.NewUnset(yyDollar[3].list)
 
@@ -3530,9 +3530,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 147:
+	case 148:
 		yyDollar = yyS[yypt-7 : yypt+1]
-		//line php7/php7.y:1209
+		//line php7/php7.y:1210
 		{
 			switch n := yyDollar[7].node.(type) {
 			case *stmt.Foreach:
@@ -3556,9 +3556,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 148:
+	case 149:
 		yyDollar = yyS[yypt-9 : yypt+1]
-		//line php7/php7.y:1234
+		//line php7/php7.y:1235
 		{
 			switch n := yyDollar[9].node.(type) {
 			case *stmt.Foreach:
@@ -3585,9 +3585,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 149:
+	case 150:
 		yyDollar = yyS[yypt-5 : yypt+1]
-		//line php7/php7.y:1261
+		//line php7/php7.y:1262
 		{
 			yyVAL.node = yyDollar[5].node
 			yyVAL.node.(*stmt.Declare).Consts = yyDollar[3].list
@@ -3602,9 +3602,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 150:
+	case 151:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1276
+		//line php7/php7.y:1277
 		{
 			yyVAL.node = stmt.NewNop()
 
@@ -3617,9 +3617,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 151:
+	case 152:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:1289
+		//line php7/php7.y:1290
 		{
 			if yyDollar[6].node == nil {
 				yyVAL.node = stmt.NewTry(yyDollar[3].list, yyDollar[5].list, yyDollar[6].node)
@@ -3636,9 +3636,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 152:
+	case 153:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1306
+		//line php7/php7.y:1307
 		{
 			yyVAL.node = stmt.NewThrow(yyDollar[2].node)
 
@@ -3652,9 +3652,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 153:
+	case 154:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1320
+		//line php7/php7.y:1321
 		{
 			label := node.NewIdentifier(yyDollar[2].token.Value)
 			yyVAL.node = stmt.NewGoto(label)
@@ -3671,9 +3671,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 154:
+	case 155:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:1337
+		//line php7/php7.y:1338
 		{
 			label := node.NewIdentifier(yyDollar[1].token.Value)
 			yyVAL.node = stmt.NewLabel(label)
@@ -3688,17 +3688,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 155:
+	case 156:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:1354
+		//line php7/php7.y:1355
 		{
 			yyVAL.list = []node.Node{}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 156:
+	case 157:
 		yyDollar = yyS[yypt-9 : yypt+1]
-		//line php7/php7.y:1360
+		//line php7/php7.y:1361
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[5].token.Value, isDollar))
 			variable := expr.NewVariable(identifier)
@@ -3721,17 +3721,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 157:
+	case 158:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1385
+		//line php7/php7.y:1386
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 158:
+	case 159:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1391
+		//line php7/php7.y:1392
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -3740,17 +3740,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 159:
+	case 160:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:1403
+		//line php7/php7.y:1404
 		{
 			yyVAL.node = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 160:
+	case 161:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:1409
+		//line php7/php7.y:1410
 		{
 			yyVAL.node = stmt.NewFinally(yyDollar[3].list)
 
@@ -3764,17 +3764,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 161:
+	case 162:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1426
+		//line php7/php7.y:1427
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 162:
+	case 163:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1432
+		//line php7/php7.y:1433
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -3783,17 +3783,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 163:
+	case 164:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1444
+		//line php7/php7.y:1445
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 164:
+	case 165:
 		yyDollar = yyS[yypt-11 : yypt+1]
-		//line php7/php7.y:1453
+		//line php7/php7.y:1454
 		{
 			name := node.NewIdentifier(yyDollar[3].token.Value)
 			yyVAL.node = stmt.NewFunction(name, yyDollar[2].token != nil, yyDollar[6].list, yyDollar[8].node, yyDollar[10].list, yyDollar[4].str)
@@ -3827,33 +3827,33 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 165:
+	case 166:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:1489
+		//line php7/php7.y:1490
 		{
 			yyVAL.token = nil
 		}
-	case 166:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1493
-		{
-			yyVAL.token = yyDollar[1].token
-		}
 	case 167:
-		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:1500
-		{
-			yyVAL.token = nil
-		}
-	case 168:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1504
+		//line php7/php7.y:1494
 		{
 			yyVAL.token = yyDollar[1].token
 		}
+	case 168:
+		yyDollar = yyS[yypt-0 : yypt+1]
+		//line php7/php7.y:1501
+		{
+			yyVAL.token = nil
+		}
 	case 169:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:1505
+		{
+			yyVAL.token = yyDollar[1].token
+		}
+	case 170:
 		yyDollar = yyS[yypt-9 : yypt+1]
-		//line php7/php7.y:1511
+		//line php7/php7.y:1512
 		{
 			name := node.NewIdentifier(yyDollar[3].token.Value)
 			yyVAL.node = stmt.NewClass(name, yyDollar[1].list, nil, yyDollar[4].ClassExtends, yyDollar[5].ClassImplements, yyDollar[8].list, yyDollar[6].str)
@@ -3871,9 +3871,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 170:
+	case 171:
 		yyDollar = yyS[yypt-8 : yypt+1]
-		//line php7/php7.y:1529
+		//line php7/php7.y:1530
 		{
 			name := node.NewIdentifier(yyDollar[2].token.Value)
 			yyVAL.node = stmt.NewClass(name, nil, nil, yyDollar[3].ClassExtends, yyDollar[4].ClassImplements, yyDollar[7].list, yyDollar[5].str)
@@ -3890,39 +3890,25 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 171:
+	case 172:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1549
+		//line php7/php7.y:1550
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 172:
+	case 173:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:1555
+		//line php7/php7.y:1556
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[2].node)
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 173:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1564
-		{
-			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 174:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1576
+		//line php7/php7.y:1565
 		{
 			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
 
@@ -3935,8 +3921,22 @@ yydefault:
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 175:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:1577
+		{
+			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 176:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:1591
+		//line php7/php7.y:1592
 		{
 			name := node.NewIdentifier(yyDollar[2].token.Value)
 			yyVAL.node = stmt.NewTrait(name, yyDollar[5].list, yyDollar[3].str)
@@ -3953,9 +3953,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 176:
+	case 177:
 		yyDollar = yyS[yypt-7 : yypt+1]
-		//line php7/php7.y:1611
+		//line php7/php7.y:1612
 		{
 			name := node.NewIdentifier(yyDollar[2].token.Value)
 			yyVAL.node = stmt.NewInterface(name, yyDollar[3].InterfaceExtends, yyDollar[6].list, yyDollar[4].str)
@@ -3972,17 +3972,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 177:
+	case 178:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:1631
+		//line php7/php7.y:1632
 		{
 			yyVAL.ClassExtends = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 178:
+	case 179:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:1637
+		//line php7/php7.y:1638
 		{
 			yyVAL.ClassExtends = stmt.NewClassExtends(yyDollar[2].node)
 
@@ -3994,17 +3994,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 179:
+	case 180:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:1652
+		//line php7/php7.y:1653
 		{
 			yyVAL.InterfaceExtends = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 180:
+	case 181:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:1658
+		//line php7/php7.y:1659
 		{
 			yyVAL.InterfaceExtends = stmt.NewInterfaceExtends(yyDollar[2].list)
 
@@ -4016,17 +4016,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 181:
+	case 182:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:1673
+		//line php7/php7.y:1674
 		{
 			yyVAL.ClassImplements = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 182:
+	case 183:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:1679
+		//line php7/php7.y:1680
 		{
 			yyVAL.ClassImplements = stmt.NewClassImplements(yyDollar[2].list)
 
@@ -4038,17 +4038,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 183:
+	case 184:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1694
+		//line php7/php7.y:1695
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 184:
+	case 185:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:1700
+		//line php7/php7.y:1701
 		{
 			yyVAL.node = expr.NewReference(yyDollar[2].node)
 
@@ -4060,9 +4060,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 185:
+	case 186:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:1712
+		//line php7/php7.y:1713
 		{
 			yyVAL.node = expr.NewList(yyDollar[3].list)
 
@@ -4076,9 +4076,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 186:
+	case 187:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1726
+		//line php7/php7.y:1727
 		{
 			yyVAL.node = expr.NewShortList(yyDollar[2].list)
 
@@ -4091,9 +4091,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 187:
+	case 188:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1742
+		//line php7/php7.y:1743
 		{
 			yyVAL.node = stmt.NewFor(nil, nil, nil, yyDollar[1].node)
 
@@ -4102,9 +4102,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 188:
+	case 189:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:1751
+		//line php7/php7.y:1752
 		{
 			stmtList := stmt.NewStmtList(yyDollar[2].list)
 			yyVAL.node = stmt.NewAltFor(nil, nil, nil, stmtList)
@@ -4121,9 +4121,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 189:
+	case 190:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1771
+		//line php7/php7.y:1772
 		{
 			yyVAL.node = stmt.NewForeach(nil, nil, nil, yyDollar[1].node)
 
@@ -4132,9 +4132,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 190:
+	case 191:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:1780
+		//line php7/php7.y:1781
 		{
 			stmtList := stmt.NewStmtList(yyDollar[2].list)
 			yyVAL.node = stmt.NewAltForeach(nil, nil, nil, stmtList)
@@ -4151,9 +4151,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 191:
+	case 192:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1800
+		//line php7/php7.y:1801
 		{
 			yyVAL.node = stmt.NewDeclare(nil, yyDollar[1].node, false)
 
@@ -4162,9 +4162,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 192:
+	case 193:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:1809
+		//line php7/php7.y:1810
 		{
 			stmtList := stmt.NewStmtList(yyDollar[2].list)
 			yyVAL.node = stmt.NewDeclare(nil, stmtList, true)
@@ -4181,9 +4181,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 193:
+	case 194:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:1829
+		//line php7/php7.y:1830
 		{
 			caseList := stmt.NewCaseList(yyDollar[2].list)
 			yyVAL.node = stmt.NewSwitch(nil, caseList)
@@ -4198,9 +4198,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 194:
+	case 195:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:1844
+		//line php7/php7.y:1845
 		{
 			caseList := stmt.NewCaseList(yyDollar[3].list)
 			yyVAL.node = stmt.NewSwitch(nil, caseList)
@@ -4216,9 +4216,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 195:
+	case 196:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:1860
+		//line php7/php7.y:1861
 		{
 			caseList := stmt.NewCaseList(yyDollar[2].list)
 			yyVAL.node = stmt.NewAltSwitch(nil, caseList)
@@ -4235,9 +4235,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 196:
+	case 197:
 		yyDollar = yyS[yypt-5 : yypt+1]
-		//line php7/php7.y:1877
+		//line php7/php7.y:1878
 		{
 
 			caseList := stmt.NewCaseList(yyDollar[3].list)
@@ -4256,17 +4256,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 197:
+	case 198:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:1899
+		//line php7/php7.y:1900
 		{
 			yyVAL.list = []node.Node{}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 198:
+	case 199:
 		yyDollar = yyS[yypt-5 : yypt+1]
-		//line php7/php7.y:1905
+		//line php7/php7.y:1906
 		{
 			_case := stmt.NewCase(yyDollar[3].node, yyDollar[5].list)
 			yyVAL.list = append(yyDollar[1].list, _case)
@@ -4281,9 +4281,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 199:
+	case 200:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:1920
+		//line php7/php7.y:1921
 		{
 			_default := stmt.NewDefault(yyDollar[4].list)
 			yyVAL.list = append(yyDollar[1].list, _default)
@@ -4298,21 +4298,21 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 200:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1938
-		{
-			yyVAL.token = yyDollar[1].token
-		}
 	case 201:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1942
+		//line php7/php7.y:1939
 		{
 			yyVAL.token = yyDollar[1].token
 		}
 	case 202:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:1949
+		//line php7/php7.y:1943
+		{
+			yyVAL.token = yyDollar[1].token
+		}
+	case 203:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:1950
 		{
 			yyVAL.node = stmt.NewWhile(nil, yyDollar[1].node)
 
@@ -4321,9 +4321,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 203:
+	case 204:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:1958
+		//line php7/php7.y:1959
 		{
 			stmtList := stmt.NewStmtList(yyDollar[2].list)
 			yyVAL.node = stmt.NewAltWhile(nil, stmtList)
@@ -4340,9 +4340,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 204:
+	case 205:
 		yyDollar = yyS[yypt-5 : yypt+1]
-		//line php7/php7.y:1978
+		//line php7/php7.y:1979
 		{
 			yyVAL.node = stmt.NewIf(yyDollar[3].node, yyDollar[5].node, nil, nil)
 
@@ -4356,9 +4356,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 205:
+	case 206:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:1992
+		//line php7/php7.y:1993
 		{
 			_elseIf := stmt.NewElseIf(yyDollar[4].node, yyDollar[6].node)
 			yyVAL.node = yyDollar[1].node.(*stmt.If).AddElseIf(_elseIf)
@@ -4374,17 +4374,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 206:
+	case 207:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2011
+		//line php7/php7.y:2012
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 207:
+	case 208:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2017
+		//line php7/php7.y:2018
 		{
 			_else := stmt.NewElse(yyDollar[3].node)
 			yyVAL.node = yyDollar[1].node.(*stmt.If).SetElse(_else)
@@ -4398,9 +4398,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 208:
+	case 209:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:2034
+		//line php7/php7.y:2035
 		{
 			stmts := stmt.NewStmtList(yyDollar[6].list)
 			yyVAL.node = stmt.NewAltIf(yyDollar[3].node, stmts, nil, nil)
@@ -4417,9 +4417,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 209:
+	case 210:
 		yyDollar = yyS[yypt-7 : yypt+1]
-		//line php7/php7.y:2051
+		//line php7/php7.y:2052
 		{
 			stmts := stmt.NewStmtList(yyDollar[7].list)
 			_elseIf := stmt.NewAltElseIf(yyDollar[4].node, stmts)
@@ -4437,9 +4437,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 210:
+	case 211:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2072
+		//line php7/php7.y:2073
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -4453,9 +4453,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 211:
+	case 212:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:2086
+		//line php7/php7.y:2087
 		{
 			stmts := stmt.NewStmtList(yyDollar[4].list)
 			_else := stmt.NewAltElse(stmts)
@@ -4475,33 +4475,33 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 212:
+	case 213:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2109
+		//line php7/php7.y:2110
 		{
 			yyVAL.list = yyDollar[1].list
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 213:
+	case 214:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:2115
+		//line php7/php7.y:2116
 		{
 			yyVAL.list = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 214:
+	case 215:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2124
+		//line php7/php7.y:2125
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 215:
+	case 216:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2130
+		//line php7/php7.y:2131
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -4510,9 +4510,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 216:
+	case 217:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:2142
+		//line php7/php7.y:2143
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[4].token.Value, isDollar))
 			variable := expr.NewVariable(identifier)
@@ -4560,9 +4560,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 217:
+	case 218:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:2187
+		//line php7/php7.y:2188
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[4].token.Value, isDollar))
 			variable := expr.NewVariable(identifier)
@@ -4611,33 +4611,33 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 218:
+	case 219:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:2236
+		//line php7/php7.y:2237
 		{
 			yyVAL.node = nil
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 219:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2242
-		{
-			yyVAL.node = yyDollar[1].node
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 220:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2251
+		//line php7/php7.y:2243
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 221:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:2252
+		{
+			yyVAL.node = yyDollar[1].node
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 222:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:2257
+		//line php7/php7.y:2258
 		{
 			yyVAL.node = node.NewNullable(yyDollar[2].node)
 
@@ -4647,25 +4647,11 @@ yydefault:
 			// save comments
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 222:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2272
-		{
-			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 223:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2284
+		//line php7/php7.y:2273
 		{
 			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
 
@@ -4679,23 +4665,37 @@ yydefault:
 		}
 	case 224:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2296
+		//line php7/php7.y:2285
+		{
+			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 225:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:2297
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 225:
+	case 226:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:2305
+		//line php7/php7.y:2306
 		{
 			yyVAL.node = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 226:
+	case 227:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:2311
+		//line php7/php7.y:2312
 		{
 			yyVAL.node = yyDollar[2].node
 
@@ -4704,9 +4704,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 227:
+	case 228:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:2323
+		//line php7/php7.y:2324
 		{
 			yyVAL.node = node.NewArgumentList(nil)
 
@@ -4719,9 +4719,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 228:
+	case 229:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:2336
+		//line php7/php7.y:2337
 		{
 			yyVAL.node = node.NewArgumentList(yyDollar[2].list)
 
@@ -4738,17 +4738,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 229:
+	case 230:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2356
+		//line php7/php7.y:2357
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 230:
+	case 231:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2362
+		//line php7/php7.y:2363
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -4757,9 +4757,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 231:
+	case 232:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2374
+		//line php7/php7.y:2375
 		{
 			yyVAL.node = node.NewArgument(yyDollar[1].node, false, false)
 
@@ -4771,9 +4771,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 232:
+	case 233:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:2386
+		//line php7/php7.y:2387
 		{
 			yyVAL.node = node.NewArgument(yyDollar[2].node, true, false)
 
@@ -4785,36 +4785,36 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 233:
+	case 234:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2401
+		//line php7/php7.y:2402
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
 			// save comments
 			yylex.(*Parser).setFreeFloating(lastNode(yyDollar[1].list), freefloating.End, yyDollar[2].token.FreeFloating)
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 234:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2410
-		{
-			yyVAL.list = []node.Node{yyDollar[1].node}
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 235:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2419
+		//line php7/php7.y:2411
+		{
+			yyVAL.list = []node.Node{yyDollar[1].node}
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 236:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:2420
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 236:
+	case 237:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2428
+		//line php7/php7.y:2429
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -4823,17 +4823,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 237:
+	case 238:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2437
+		//line php7/php7.y:2438
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 238:
+	case 239:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2446
+		//line php7/php7.y:2447
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[1].token.Value, isDollar))
 			variable := expr.NewVariable(identifier)
@@ -4850,9 +4850,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 239:
+	case 240:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2463
+		//line php7/php7.y:2464
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[1].token.Value, isDollar))
 			variable := expr.NewVariable(identifier)
@@ -4870,25 +4870,25 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 240:
+	case 241:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:2484
+		//line php7/php7.y:2485
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[2].node)
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 241:
+	case 242:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:2490
+		//line php7/php7.y:2491
 		{
 			yyVAL.list = []node.Node{}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 242:
+	case 243:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2499
+		//line php7/php7.y:2500
 		{
 			yyVAL.node = stmt.NewPropertyList(yyDollar[1].list, yyDollar[2].list)
 
@@ -4902,9 +4902,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 243:
+	case 244:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:2513
+		//line php7/php7.y:2514
 		{
 			yyVAL.node = stmt.NewClassConstList(yyDollar[1].list, yyDollar[3].list)
 
@@ -4923,9 +4923,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 244:
+	case 245:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2532
+		//line php7/php7.y:2533
 		{
 			yyVAL.node = stmt.NewTraitUse(yyDollar[2].list, yyDollar[3].node)
 
@@ -4937,9 +4937,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 245:
+	case 246:
 		yyDollar = yyS[yypt-10 : yypt+1]
-		//line php7/php7.y:2544
+		//line php7/php7.y:2545
 		{
 			name := node.NewIdentifier(yyDollar[4].token.Value)
 			yyVAL.node = stmt.NewClassMethod(name, yyDollar[1].list, yyDollar[3].token != nil, yyDollar[7].list, yyDollar[9].node, yyDollar[10].node, yyDollar[5].str)
@@ -4974,17 +4974,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 246:
+	case 247:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2581
+		//line php7/php7.y:2582
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 247:
+	case 248:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2587
+		//line php7/php7.y:2588
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -4993,9 +4993,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 248:
+	case 249:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2599
+		//line php7/php7.y:2600
 		{
 			yyVAL.node = stmt.NewNop()
 
@@ -5007,9 +5007,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 249:
+	case 250:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:2612
+		//line php7/php7.y:2613
 		{
 			yyVAL.node = stmt.NewTraitAdaptationList(nil)
 
@@ -5021,9 +5021,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 250:
+	case 251:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2624
+		//line php7/php7.y:2625
 		{
 			yyVAL.node = stmt.NewTraitAdaptationList(yyDollar[2].list)
 
@@ -5035,25 +5035,25 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 251:
+	case 252:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2639
+		//line php7/php7.y:2640
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 252:
+	case 253:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:2645
+		//line php7/php7.y:2646
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[2].node)
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 253:
+	case 254:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:2654
+		//line php7/php7.y:2655
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -5063,9 +5063,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 254:
+	case 255:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:2664
+		//line php7/php7.y:2665
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -5075,9 +5075,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 255:
+	case 256:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2677
+		//line php7/php7.y:2678
 		{
 			yyVAL.node = stmt.NewTraitUsePrecedence(yyDollar[1].node, yyDollar[3].list)
 
@@ -5088,29 +5088,11 @@ yydefault:
 			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Ref, yyDollar[2].token.FreeFloating)
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 256:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2693
-		{
-			alias := node.NewIdentifier(yyDollar[3].token.Value)
-			yyVAL.node = stmt.NewTraitUseAlias(yyDollar[1].node, nil, alias)
-
-			// save position
-			alias.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[3].token))
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[3].token))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Ref, yyDollar[2].token.FreeFloating)
-			yylex.(*Parser).setFreeFloating(alias, freefloating.Start, yyDollar[3].token.FreeFloating)
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 257:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2709
+		//line php7/php7.y:2694
 		{
 			alias := node.NewIdentifier(yyDollar[3].token.Value)
 			yyVAL.node = stmt.NewTraitUseAlias(yyDollar[1].node, nil, alias)
@@ -5127,8 +5109,26 @@ yydefault:
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 258:
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line php7/php7.y:2710
+		{
+			alias := node.NewIdentifier(yyDollar[3].token.Value)
+			yyVAL.node = stmt.NewTraitUseAlias(yyDollar[1].node, nil, alias)
+
+			// save position
+			alias.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[3].token))
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[3].token))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Ref, yyDollar[2].token.FreeFloating)
+			yylex.(*Parser).setFreeFloating(alias, freefloating.Start, yyDollar[3].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 259:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:2725
+		//line php7/php7.y:2726
 		{
 			alias := node.NewIdentifier(yyDollar[4].token.Value)
 			yyVAL.node = stmt.NewTraitUseAlias(yyDollar[1].node, yyDollar[3].node, alias)
@@ -5144,9 +5144,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 259:
+	case 260:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2741
+		//line php7/php7.y:2742
 		{
 			yyVAL.node = stmt.NewTraitUseAlias(yyDollar[1].node, yyDollar[3].node, nil)
 
@@ -5159,9 +5159,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 260:
+	case 261:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2757
+		//line php7/php7.y:2758
 		{
 			name := node.NewIdentifier(yyDollar[1].token.Value)
 			yyVAL.node = stmt.NewTraitMethodRef(nil, name)
@@ -5175,17 +5175,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 261:
+	case 262:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2771
+		//line php7/php7.y:2772
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 262:
+	case 263:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2780
+		//line php7/php7.y:2781
 		{
 			target := node.NewIdentifier(yyDollar[3].token.Value)
 			yyVAL.node = stmt.NewTraitMethodRef(yyDollar[1].node, target)
@@ -5201,9 +5201,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 263:
+	case 264:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2799
+		//line php7/php7.y:2800
 		{
 			yyVAL.node = stmt.NewNop()
 
@@ -5216,9 +5216,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 264:
+	case 265:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2812
+		//line php7/php7.y:2813
 		{
 			yyVAL.node = stmt.NewStmtList(yyDollar[2].list)
 
@@ -5231,17 +5231,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 265:
+	case 266:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2828
+		//line php7/php7.y:2829
 		{
 			yyVAL.list = yyDollar[1].list
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 266:
+	case 267:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2834
+		//line php7/php7.y:2835
 		{
 			modifier := node.NewIdentifier(yyDollar[1].token.Value)
 			yyVAL.list = []node.Node{modifier}
@@ -5254,55 +5254,41 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 267:
+	case 268:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:2850
+		//line php7/php7.y:2851
 		{
 			yyVAL.list = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 268:
+	case 269:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2856
+		//line php7/php7.y:2857
 		{
 			yyVAL.list = yyDollar[1].list
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 269:
+	case 270:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2865
+		//line php7/php7.y:2866
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 270:
+	case 271:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:2871
+		//line php7/php7.y:2872
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[2].node)
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 271:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2880
-		{
-			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 272:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2892
+		//line php7/php7.y:2881
 		{
 			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
 
@@ -5316,7 +5302,7 @@ yydefault:
 		}
 	case 273:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2904
+		//line php7/php7.y:2893
 		{
 			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
 
@@ -5330,7 +5316,7 @@ yydefault:
 		}
 	case 274:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2916
+		//line php7/php7.y:2905
 		{
 			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
 
@@ -5344,7 +5330,7 @@ yydefault:
 		}
 	case 275:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2928
+		//line php7/php7.y:2917
 		{
 			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
 
@@ -5358,7 +5344,7 @@ yydefault:
 		}
 	case 276:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2940
+		//line php7/php7.y:2929
 		{
 			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
 
@@ -5371,8 +5357,22 @@ yydefault:
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 277:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:2941
+		{
+			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 278:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:2955
+		//line php7/php7.y:2956
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -5381,17 +5381,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 278:
+	case 279:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:2964
+		//line php7/php7.y:2965
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 279:
+	case 280:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:2973
+		//line php7/php7.y:2974
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[1].token.Value, isDollar))
 			variable := expr.NewVariable(identifier)
@@ -5408,9 +5408,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 280:
+	case 281:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:2990
+		//line php7/php7.y:2991
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[1].token.Value, isDollar))
 			variable := expr.NewVariable(identifier)
@@ -5428,9 +5428,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 281:
+	case 282:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3011
+		//line php7/php7.y:3012
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -5439,34 +5439,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 282:
+	case 283:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:3020
+		//line php7/php7.y:3021
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 283:
-		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:3029
-		{
-			name := node.NewIdentifier(yyDollar[1].token.Value)
-			yyVAL.node = stmt.NewConstant(name, yyDollar[3].node, yyDollar[4].str)
-
-			// save position
-			name.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenNodePosition(yyDollar[1].token, yyDollar[3].node))
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 284:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:3047
+		//line php7/php7.y:3030
 		{
 			name := node.NewIdentifier(yyDollar[1].token.Value)
 			yyVAL.node = stmt.NewConstant(name, yyDollar[3].node, yyDollar[4].str)
@@ -5482,51 +5465,68 @@ yydefault:
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 285:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line php7/php7.y:3048
+		{
+			name := node.NewIdentifier(yyDollar[1].token.Value)
+			yyVAL.node = stmt.NewConstant(name, yyDollar[3].node, yyDollar[4].str)
+
+			// save position
+			name.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenNodePosition(yyDollar[1].token, yyDollar[3].node))
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 286:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3065
+		//line php7/php7.y:3066
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
 			// save comments
 			yylex.(*Parser).setFreeFloating(lastNode(yyDollar[1].list), freefloating.End, yyDollar[2].token.FreeFloating)
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 286:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:3074
-		{
-			yyVAL.list = []node.Node{yyDollar[1].node}
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 287:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:3083
+		//line php7/php7.y:3075
+		{
+			yyVAL.list = []node.Node{yyDollar[1].node}
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 288:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:3084
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 288:
+	case 289:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:3092
+		//line php7/php7.y:3093
 		{
 			yyVAL.list = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 289:
+	case 290:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:3098
+		//line php7/php7.y:3099
 		{
 			yyVAL.list = yyDollar[1].list
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 290:
+	case 291:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3107
+		//line php7/php7.y:3108
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -5535,17 +5535,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 291:
+	case 292:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:3116
+		//line php7/php7.y:3117
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 292:
+	case 293:
 		yyDollar = yyS[yypt-8 : yypt+1]
-		//line php7/php7.y:3125
+		//line php7/php7.y:3126
 		{
 			if yyDollar[2].node != nil {
 				yyVAL.node = stmt.NewClass(nil, nil, yyDollar[2].node.(*node.ArgumentList), yyDollar[3].ClassExtends, yyDollar[4].ClassImplements, yyDollar[7].list, yyDollar[5].str)
@@ -5563,9 +5563,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 293:
+	case 294:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3146
+		//line php7/php7.y:3147
 		{
 			if yyDollar[3].node != nil {
 				yyVAL.node = expr.NewNew(yyDollar[2].node, yyDollar[3].node.(*node.ArgumentList))
@@ -5580,9 +5580,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 294:
+	case 295:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3161
+		//line php7/php7.y:3162
 		{
 			yyVAL.node = expr.NewNew(yyDollar[2].node, nil)
 
@@ -5594,9 +5594,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 295:
+	case 296:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:3176
+		//line php7/php7.y:3177
 		{
 			listNode := expr.NewList(yyDollar[3].list)
 			yyVAL.node = assign.NewAssign(listNode, yyDollar[6].node)
@@ -5613,9 +5613,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 296:
+	case 297:
 		yyDollar = yyS[yypt-5 : yypt+1]
-		//line php7/php7.y:3193
+		//line php7/php7.y:3194
 		{
 			shortList := expr.NewShortList(yyDollar[2].list)
 			yyVAL.node = assign.NewAssign(shortList, yyDollar[5].node)
@@ -5631,9 +5631,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 297:
+	case 298:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3209
+		//line php7/php7.y:3210
 		{
 			yyVAL.node = assign.NewAssign(yyDollar[1].node, yyDollar[3].node)
 
@@ -5646,9 +5646,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 298:
+	case 299:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:3222
+		//line php7/php7.y:3223
 		{
 			yyVAL.node = assign.NewReference(yyDollar[1].node, yyDollar[4].node)
 
@@ -5662,9 +5662,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 299:
+	case 300:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3236
+		//line php7/php7.y:3237
 		{
 			yyVAL.node = expr.NewClone(yyDollar[2].node)
 
@@ -5676,9 +5676,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 300:
+	case 301:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3248
+		//line php7/php7.y:3249
 		{
 			yyVAL.node = assign.NewPlus(yyDollar[1].node, yyDollar[3].node)
 
@@ -5691,9 +5691,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 301:
+	case 302:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3261
+		//line php7/php7.y:3262
 		{
 			yyVAL.node = assign.NewMinus(yyDollar[1].node, yyDollar[3].node)
 
@@ -5706,9 +5706,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 302:
+	case 303:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3274
+		//line php7/php7.y:3275
 		{
 			yyVAL.node = assign.NewMul(yyDollar[1].node, yyDollar[3].node)
 
@@ -5721,9 +5721,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 303:
+	case 304:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3287
+		//line php7/php7.y:3288
 		{
 			yyVAL.node = assign.NewPow(yyDollar[1].node, yyDollar[3].node)
 
@@ -5736,9 +5736,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 304:
+	case 305:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3300
+		//line php7/php7.y:3301
 		{
 			yyVAL.node = assign.NewDiv(yyDollar[1].node, yyDollar[3].node)
 
@@ -5751,9 +5751,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 305:
+	case 306:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3313
+		//line php7/php7.y:3314
 		{
 			yyVAL.node = assign.NewConcat(yyDollar[1].node, yyDollar[3].node)
 
@@ -5766,9 +5766,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 306:
+	case 307:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3326
+		//line php7/php7.y:3327
 		{
 			yyVAL.node = assign.NewMod(yyDollar[1].node, yyDollar[3].node)
 
@@ -5781,9 +5781,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 307:
+	case 308:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3339
+		//line php7/php7.y:3340
 		{
 			yyVAL.node = assign.NewBitwiseAnd(yyDollar[1].node, yyDollar[3].node)
 
@@ -5796,9 +5796,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 308:
+	case 309:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3352
+		//line php7/php7.y:3353
 		{
 			yyVAL.node = assign.NewBitwiseOr(yyDollar[1].node, yyDollar[3].node)
 
@@ -5811,9 +5811,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 309:
+	case 310:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3365
+		//line php7/php7.y:3366
 		{
 			yyVAL.node = assign.NewBitwiseXor(yyDollar[1].node, yyDollar[3].node)
 
@@ -5826,9 +5826,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 310:
+	case 311:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3378
+		//line php7/php7.y:3379
 		{
 			yyVAL.node = assign.NewShiftLeft(yyDollar[1].node, yyDollar[3].node)
 
@@ -5841,9 +5841,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 311:
+	case 312:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3391
+		//line php7/php7.y:3392
 		{
 			yyVAL.node = assign.NewShiftRight(yyDollar[1].node, yyDollar[3].node)
 
@@ -5856,9 +5856,24 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 312:
+	case 313:
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line php7/php7.y:3405
+		{
+			yyVAL.node = assign.NewCoalesce(yyDollar[1].node, yyDollar[3].node)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[3].node))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, yyDollar[2].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 314:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3404
+		//line php7/php7.y:3418
 		{
 			yyVAL.node = expr.NewPostInc(yyDollar[1].node)
 
@@ -5871,9 +5886,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 313:
+	case 315:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3417
+		//line php7/php7.y:3431
 		{
 			yyVAL.node = expr.NewPreInc(yyDollar[2].node)
 
@@ -5885,9 +5900,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 314:
+	case 316:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3429
+		//line php7/php7.y:3443
 		{
 			yyVAL.node = expr.NewPostDec(yyDollar[1].node)
 
@@ -5900,9 +5915,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 315:
+	case 317:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3442
+		//line php7/php7.y:3456
 		{
 			yyVAL.node = expr.NewPreDec(yyDollar[2].node)
 
@@ -5914,9 +5929,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 316:
+	case 318:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3454
+		//line php7/php7.y:3468
 		{
 			yyVAL.node = binary.NewBooleanOr(yyDollar[1].node, yyDollar[3].node)
 
@@ -5929,9 +5944,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 317:
+	case 319:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3467
+		//line php7/php7.y:3481
 		{
 			yyVAL.node = binary.NewBooleanAnd(yyDollar[1].node, yyDollar[3].node)
 
@@ -5944,9 +5959,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 318:
+	case 320:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3480
+		//line php7/php7.y:3494
 		{
 			yyVAL.node = binary.NewLogicalOr(yyDollar[1].node, yyDollar[3].node)
 
@@ -5959,9 +5974,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 319:
+	case 321:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3493
+		//line php7/php7.y:3507
 		{
 			yyVAL.node = binary.NewLogicalAnd(yyDollar[1].node, yyDollar[3].node)
 
@@ -5974,9 +5989,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 320:
+	case 322:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3506
+		//line php7/php7.y:3520
 		{
 			yyVAL.node = binary.NewLogicalXor(yyDollar[1].node, yyDollar[3].node)
 
@@ -5989,9 +6004,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 321:
+	case 323:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3519
+		//line php7/php7.y:3533
 		{
 			yyVAL.node = binary.NewBitwiseOr(yyDollar[1].node, yyDollar[3].node)
 
@@ -6004,9 +6019,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 322:
+	case 324:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3532
+		//line php7/php7.y:3546
 		{
 			yyVAL.node = binary.NewBitwiseAnd(yyDollar[1].node, yyDollar[3].node)
 
@@ -6019,9 +6034,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 323:
+	case 325:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3545
+		//line php7/php7.y:3559
 		{
 			yyVAL.node = binary.NewBitwiseXor(yyDollar[1].node, yyDollar[3].node)
 
@@ -6034,9 +6049,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 324:
+	case 326:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3558
+		//line php7/php7.y:3572
 		{
 			yyVAL.node = binary.NewConcat(yyDollar[1].node, yyDollar[3].node)
 
@@ -6049,9 +6064,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 325:
+	case 327:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3571
+		//line php7/php7.y:3585
 		{
 			yyVAL.node = binary.NewPlus(yyDollar[1].node, yyDollar[3].node)
 
@@ -6064,9 +6079,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 326:
+	case 328:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3584
+		//line php7/php7.y:3598
 		{
 			yyVAL.node = binary.NewMinus(yyDollar[1].node, yyDollar[3].node)
 
@@ -6079,9 +6094,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 327:
+	case 329:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3597
+		//line php7/php7.y:3611
 		{
 			yyVAL.node = binary.NewMul(yyDollar[1].node, yyDollar[3].node)
 
@@ -6094,9 +6109,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 328:
+	case 330:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3610
+		//line php7/php7.y:3624
 		{
 			yyVAL.node = binary.NewPow(yyDollar[1].node, yyDollar[3].node)
 
@@ -6109,9 +6124,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 329:
+	case 331:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3623
+		//line php7/php7.y:3637
 		{
 			yyVAL.node = binary.NewDiv(yyDollar[1].node, yyDollar[3].node)
 
@@ -6124,9 +6139,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 330:
+	case 332:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3636
+		//line php7/php7.y:3650
 		{
 			yyVAL.node = binary.NewMod(yyDollar[1].node, yyDollar[3].node)
 
@@ -6139,9 +6154,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 331:
+	case 333:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3649
+		//line php7/php7.y:3663
 		{
 			yyVAL.node = binary.NewShiftLeft(yyDollar[1].node, yyDollar[3].node)
 
@@ -6154,9 +6169,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 332:
+	case 334:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3662
+		//line php7/php7.y:3676
 		{
 			yyVAL.node = binary.NewShiftRight(yyDollar[1].node, yyDollar[3].node)
 
@@ -6169,9 +6184,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 333:
+	case 335:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3675
+		//line php7/php7.y:3689
 		{
 			yyVAL.node = expr.NewUnaryPlus(yyDollar[2].node)
 
@@ -6183,9 +6198,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 334:
+	case 336:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3687
+		//line php7/php7.y:3701
 		{
 			yyVAL.node = expr.NewUnaryMinus(yyDollar[2].node)
 
@@ -6197,9 +6212,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 335:
+	case 337:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3699
+		//line php7/php7.y:3713
 		{
 			yyVAL.node = expr.NewBooleanNot(yyDollar[2].node)
 
@@ -6211,9 +6226,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 336:
+	case 338:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3711
+		//line php7/php7.y:3725
 		{
 			yyVAL.node = expr.NewBitwiseNot(yyDollar[2].node)
 
@@ -6225,9 +6240,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 337:
+	case 339:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3723
+		//line php7/php7.y:3737
 		{
 			yyVAL.node = binary.NewIdentical(yyDollar[1].node, yyDollar[3].node)
 
@@ -6240,9 +6255,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 338:
+	case 340:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3736
+		//line php7/php7.y:3750
 		{
 			yyVAL.node = binary.NewNotIdentical(yyDollar[1].node, yyDollar[3].node)
 
@@ -6255,9 +6270,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 339:
+	case 341:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3749
+		//line php7/php7.y:3763
 		{
 			yyVAL.node = binary.NewEqual(yyDollar[1].node, yyDollar[3].node)
 
@@ -6270,9 +6285,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 340:
+	case 342:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3762
+		//line php7/php7.y:3776
 		{
 			yyVAL.node = binary.NewNotEqual(yyDollar[1].node, yyDollar[3].node)
 
@@ -6286,9 +6301,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 341:
+	case 343:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3776
+		//line php7/php7.y:3790
 		{
 			yyVAL.node = binary.NewSmaller(yyDollar[1].node, yyDollar[3].node)
 
@@ -6301,9 +6316,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 342:
+	case 344:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3789
+		//line php7/php7.y:3803
 		{
 			yyVAL.node = binary.NewSmallerOrEqual(yyDollar[1].node, yyDollar[3].node)
 
@@ -6316,9 +6331,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 343:
+	case 345:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3802
+		//line php7/php7.y:3816
 		{
 			yyVAL.node = binary.NewGreater(yyDollar[1].node, yyDollar[3].node)
 
@@ -6331,9 +6346,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 344:
+	case 346:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3815
+		//line php7/php7.y:3829
 		{
 			yyVAL.node = binary.NewGreaterOrEqual(yyDollar[1].node, yyDollar[3].node)
 
@@ -6346,9 +6361,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 345:
+	case 347:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3828
+		//line php7/php7.y:3842
 		{
 			yyVAL.node = binary.NewSpaceship(yyDollar[1].node, yyDollar[3].node)
 
@@ -6361,9 +6376,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 346:
+	case 348:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3841
+		//line php7/php7.y:3855
 		{
 			yyVAL.node = expr.NewInstanceOf(yyDollar[1].node, yyDollar[3].node)
 
@@ -6376,9 +6391,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 347:
+	case 349:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3854
+		//line php7/php7.y:3868
 		{
 			yyVAL.node = yyDollar[2].node
 
@@ -6388,17 +6403,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 348:
+	case 350:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:3864
+		//line php7/php7.y:3878
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 349:
+	case 351:
 		yyDollar = yyS[yypt-5 : yypt+1]
-		//line php7/php7.y:3870
+		//line php7/php7.y:3884
 		{
 			yyVAL.node = expr.NewTernary(yyDollar[1].node, yyDollar[3].node, yyDollar[5].node)
 
@@ -6412,9 +6427,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 350:
+	case 352:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:3884
+		//line php7/php7.y:3898
 		{
 			yyVAL.node = expr.NewTernary(yyDollar[1].node, nil, yyDollar[4].node)
 
@@ -6428,9 +6443,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 351:
+	case 353:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:3898
+		//line php7/php7.y:3912
 		{
 			yyVAL.node = binary.NewCoalesce(yyDollar[1].node, yyDollar[3].node)
 
@@ -6443,17 +6458,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 352:
+	case 354:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:3911
+		//line php7/php7.y:3925
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 353:
+	case 355:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3917
+		//line php7/php7.y:3931
 		{
 			yyVAL.node = cast.NewInt(yyDollar[2].node)
 
@@ -6466,9 +6481,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 354:
+	case 356:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3930
+		//line php7/php7.y:3944
 		{
 			yyVAL.node = cast.NewDouble(yyDollar[2].node)
 
@@ -6481,9 +6496,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 355:
+	case 357:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3943
+		//line php7/php7.y:3957
 		{
 			yyVAL.node = cast.NewString(yyDollar[2].node)
 
@@ -6496,9 +6511,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 356:
+	case 358:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3956
+		//line php7/php7.y:3970
 		{
 			yyVAL.node = cast.NewArray(yyDollar[2].node)
 
@@ -6511,9 +6526,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 357:
+	case 359:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3969
+		//line php7/php7.y:3983
 		{
 			yyVAL.node = cast.NewObject(yyDollar[2].node)
 
@@ -6526,9 +6541,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 358:
+	case 360:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3982
+		//line php7/php7.y:3996
 		{
 			yyVAL.node = cast.NewBool(yyDollar[2].node)
 
@@ -6541,9 +6556,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 359:
+	case 361:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:3995
+		//line php7/php7.y:4009
 		{
 			yyVAL.node = cast.NewUnset(yyDollar[2].node)
 
@@ -6556,9 +6571,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 360:
+	case 362:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:4008
+		//line php7/php7.y:4022
 		{
 			var e *expr.Exit
 			if yyDollar[2].node != nil {
@@ -6585,9 +6600,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 361:
+	case 363:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:4035
+		//line php7/php7.y:4049
 		{
 			yyVAL.node = expr.NewErrorSuppress(yyDollar[2].node)
 
@@ -6599,17 +6614,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 362:
+	case 364:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4047
+		//line php7/php7.y:4061
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 363:
+	case 365:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4053
+		//line php7/php7.y:4067
 		{
 			yyVAL.node = expr.NewShellExec(yyDollar[2].list)
 
@@ -6621,9 +6636,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 364:
+	case 366:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:4065
+		//line php7/php7.y:4079
 		{
 			yyVAL.node = expr.NewPrint(yyDollar[2].node)
 
@@ -6635,9 +6650,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 365:
+	case 367:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4077
+		//line php7/php7.y:4091
 		{
 			yyVAL.node = expr.NewYield(nil, nil)
 
@@ -6649,9 +6664,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 366:
+	case 368:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:4089
+		//line php7/php7.y:4103
 		{
 			yyVAL.node = expr.NewYield(nil, yyDollar[2].node)
 
@@ -6663,9 +6678,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 367:
+	case 369:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4101
+		//line php7/php7.y:4115
 		{
 			yyVAL.node = expr.NewYield(yyDollar[2].node, yyDollar[4].node)
 
@@ -6678,9 +6693,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 368:
+	case 370:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:4114
+		//line php7/php7.y:4128
 		{
 			yyVAL.node = expr.NewYieldFrom(yyDollar[2].node)
 
@@ -6692,9 +6707,40 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 369:
+	case 371:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:4140
+		{
+			yyVAL.node = yyDollar[1].node
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 372:
+		yyDollar = yyS[yypt-2 : yypt+1]
+		//line php7/php7.y:4146
+		{
+			yyVAL.node = yyDollar[2].node
+
+			switch n := yyVAL.node.(type) {
+			case *expr.Closure:
+				n.Static = true
+			case *expr.ArrowFunction:
+				n.Static = true
+			}
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node))
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Static, (*yyVAL.node.GetFreeFloating())[freefloating.Start])
+			delete((*yyVAL.node.GetFreeFloating()), freefloating.Start)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 373:
 		yyDollar = yyS[yypt-11 : yypt+1]
-		//line php7/php7.y:4126
+		//line php7/php7.y:4169
 		{
 			yyVAL.node = expr.NewClosure(yyDollar[5].list, yyDollar[7].ClosureUse, yyDollar[8].node, yyDollar[10].list, false, yyDollar[2].token != nil, yyDollar[3].str)
 
@@ -6729,76 +6775,70 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 370:
-		yyDollar = yyS[yypt-12 : yypt+1]
-		//line php7/php7.y:4158
+	case 374:
+		yyDollar = yyS[yypt-9 : yypt+1]
+		//line php7/php7.y:4201
 		{
-			yyVAL.node = expr.NewClosure(yyDollar[6].list, yyDollar[8].ClosureUse, yyDollar[9].node, yyDollar[11].list, true, yyDollar[3].token != nil, yyDollar[4].str)
+			yyVAL.node = expr.NewArrowFunction(yyDollar[4].list, yyDollar[6].node, yyDollar[9].node, false, yyDollar[2].token != nil, yyDollar[7].str)
 
 			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokensPosition(yyDollar[1].token, yyDollar[12].token))
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenNodePosition(yyDollar[1].token, yyDollar[9].node))
 
 			// save comments
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Static, yyDollar[2].token.FreeFloating)
-			if yyDollar[3].token == nil {
-				yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Function, yyDollar[5].token.FreeFloating)
-			} else {
+			if yyDollar[2].token == nil {
 				yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Function, yyDollar[3].token.FreeFloating)
-				yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Ampersand, yyDollar[5].token.FreeFloating)
+			} else {
+				yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Function, yyDollar[2].token.FreeFloating)
+				yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Ampersand, yyDollar[3].token.FreeFloating)
 			}
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.ParameterList, yyDollar[7].token.FreeFloating)
-			if yyDollar[9].node != nil {
-				yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.LexicalVars, (*yyDollar[9].node.GetFreeFloating())[freefloating.Colon])
-				delete((*yyDollar[9].node.GetFreeFloating()), freefloating.Colon)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.ParameterList, yyDollar[5].token.FreeFloating)
+			if yyDollar[6].node != nil {
+				yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Params, (*yyDollar[6].node.GetFreeFloating())[freefloating.Colon])
+				delete((*yyDollar[6].node.GetFreeFloating()), freefloating.Colon)
 			}
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.ReturnType, yyDollar[10].token.FreeFloating)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Stmts, yyDollar[12].token.FreeFloating)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.ReturnType, yyDollar[8].token.FreeFloating)
 
 			// normalize
-			if yyDollar[9].node == nil {
-				yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.LexicalVars, (*yyVAL.node.GetFreeFloating())[freefloating.ReturnType])
+			if yyDollar[6].node == nil {
+				yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Params, (*yyVAL.node.GetFreeFloating())[freefloating.ReturnType])
 				delete((*yyVAL.node.GetFreeFloating()), freefloating.ReturnType)
 			}
-			if yyDollar[8].ClosureUse == nil {
-				yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Params, (*yyVAL.node.GetFreeFloating())[freefloating.LexicalVarList])
-				delete((*yyVAL.node.GetFreeFloating()), freefloating.LexicalVarList)
-			}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 371:
+	case 375:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:4194
+		//line php7/php7.y:4232
 		{
 			yyVAL.str = yylex.(*Parser).Lexer.GetPhpDocComment()
 			yylex.(*Parser).Lexer.SetPhpDocComment("")
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 372:
+	case 376:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:4204
+		//line php7/php7.y:4242
 		{
 			yyVAL.token = nil
 		}
-	case 373:
+	case 377:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4208
+		//line php7/php7.y:4246
 		{
 			yyVAL.token = yyDollar[1].token
 		}
-	case 374:
+	case 378:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:4215
+		//line php7/php7.y:4253
 		{
 			yyVAL.ClosureUse = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 375:
+	case 379:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4221
+		//line php7/php7.y:4259
 		{
 			yyVAL.ClosureUse = expr.NewClosureUse(yyDollar[3].list)
 
@@ -6812,9 +6852,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 376:
+	case 380:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4238
+		//line php7/php7.y:4276
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -6823,17 +6863,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 377:
+	case 381:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4247
+		//line php7/php7.y:4285
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 378:
+	case 382:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4256
+		//line php7/php7.y:4294
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[1].token.Value, isDollar))
 			yyVAL.node = expr.NewVariable(identifier)
@@ -6848,9 +6888,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 379:
+	case 383:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:4271
+		//line php7/php7.y:4309
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[2].token.Value, isDollar))
 			variable := expr.NewVariable(identifier)
@@ -6868,51 +6908,7 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 380:
-		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:4292
-		{
-			yyVAL.node = expr.NewFunctionCall(yyDollar[1].node, yyDollar[2].node.(*node.ArgumentList))
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[2].node))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 381:
-		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4304
-		{
-			yyVAL.node = expr.NewStaticCall(yyDollar[1].node, yyDollar[3].node, yyDollar[4].node.(*node.ArgumentList))
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[4].node))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 382:
-		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4317
-		{
-			yyVAL.node = expr.NewStaticCall(yyDollar[1].node, yyDollar[3].node, yyDollar[4].node.(*node.ArgumentList))
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[4].node))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 383:
+	case 384:
 		yyDollar = yyS[yypt-2 : yypt+1]
 		//line php7/php7.y:4330
 		{
@@ -6926,9 +6922,53 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 384:
+	case 385:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line php7/php7.y:4342
+		{
+			yyVAL.node = expr.NewStaticCall(yyDollar[1].node, yyDollar[3].node, yyDollar[4].node.(*node.ArgumentList))
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[4].node))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 386:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line php7/php7.y:4355
+		{
+			yyVAL.node = expr.NewStaticCall(yyDollar[1].node, yyDollar[3].node, yyDollar[4].node.(*node.ArgumentList))
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[4].node))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 387:
+		yyDollar = yyS[yypt-2 : yypt+1]
+		//line php7/php7.y:4368
+		{
+			yyVAL.node = expr.NewFunctionCall(yyDollar[1].node, yyDollar[2].node.(*node.ArgumentList))
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[2].node))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 388:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4345
+		//line php7/php7.y:4383
 		{
 			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
 
@@ -6940,41 +6980,41 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 385:
+	case 389:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4357
+		//line php7/php7.y:4395
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 386:
+	case 390:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4366
+		//line php7/php7.y:4404
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 387:
+	case 391:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4372
+		//line php7/php7.y:4410
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 388:
+	case 392:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:4381
+		//line php7/php7.y:4419
 		{
 			yyVAL.node = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 389:
+	case 393:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4387
+		//line php7/php7.y:4425
 		{
 			yyVAL.node = expr.NewExit(yyDollar[2].node)
 
@@ -6987,17 +7027,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 390:
+	case 394:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:4403
+		//line php7/php7.y:4441
 		{
 			yyVAL.list = []node.Node{}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 391:
+	case 395:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4409
+		//line php7/php7.y:4447
 		{
 			part := scalar.NewEncapsedStringPart(yyDollar[1].token.Value)
 			yyVAL.list = []node.Node{part}
@@ -7007,33 +7047,33 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 392:
+	case 396:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4419
+		//line php7/php7.y:4457
 		{
 			yyVAL.list = yyDollar[1].list
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 393:
+	case 397:
 		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:4428
+		//line php7/php7.y:4466
 		{
 			yyVAL.node = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 394:
+	case 398:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4434
+		//line php7/php7.y:4472
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 395:
+	case 399:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4443
+		//line php7/php7.y:4481
 		{
 			yyVAL.node = expr.NewArray(yyDollar[3].list)
 
@@ -7047,9 +7087,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 396:
+	case 400:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4457
+		//line php7/php7.y:4495
 		{
 			yyVAL.node = expr.NewShortArray(yyDollar[2].list)
 
@@ -7062,9 +7102,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 397:
+	case 401:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4470
+		//line php7/php7.y:4508
 		{
 			yyVAL.node = scalar.NewString(yyDollar[1].token.Value)
 
@@ -7076,9 +7116,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 398:
+	case 402:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4485
+		//line php7/php7.y:4523
 		{
 			yyVAL.node = scalar.NewLnumber(yyDollar[1].token.Value)
 
@@ -7090,9 +7130,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 399:
+	case 403:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4497
+		//line php7/php7.y:4535
 		{
 			yyVAL.node = scalar.NewDnumber(yyDollar[1].token.Value)
 
@@ -7102,67 +7142,11 @@ yydefault:
 			// save comments
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 400:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4509
-		{
-			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 401:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4521
-		{
-			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 402:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4533
-		{
-			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 403:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4545
-		{
-			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 404:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4557
+		//line php7/php7.y:4547
 		{
 			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
 
@@ -7176,7 +7160,7 @@ yydefault:
 		}
 	case 405:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4569
+		//line php7/php7.y:4559
 		{
 			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
 
@@ -7190,7 +7174,7 @@ yydefault:
 		}
 	case 406:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4581
+		//line php7/php7.y:4571
 		{
 			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
 
@@ -7204,7 +7188,7 @@ yydefault:
 		}
 	case 407:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4593
+		//line php7/php7.y:4583
 		{
 			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
 
@@ -7217,8 +7201,64 @@ yydefault:
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 408:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:4595
+		{
+			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 409:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:4607
+		{
+			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 410:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:4619
+		{
+			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 411:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:4631
+		{
+			yyVAL.node = scalar.NewMagicConstant(yyDollar[1].token.Value)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 412:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4605
+		//line php7/php7.y:4643
 		{
 			encapsed := scalar.NewEncapsedStringPart(yyDollar[2].token.Value)
 			yyVAL.node = scalar.NewHeredoc(yyDollar[1].token.Value, []node.Node{encapsed})
@@ -7232,9 +7272,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 409:
+	case 413:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:4619
+		//line php7/php7.y:4657
 		{
 			yyVAL.node = scalar.NewHeredoc(yyDollar[1].token.Value, nil)
 
@@ -7246,9 +7286,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 410:
+	case 414:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4631
+		//line php7/php7.y:4669
 		{
 			yyVAL.node = scalar.NewEncapsed(yyDollar[2].list)
 
@@ -7260,9 +7300,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 411:
+	case 415:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4643
+		//line php7/php7.y:4681
 		{
 			yyVAL.node = scalar.NewHeredoc(yyDollar[1].token.Value, yyDollar[2].list)
 
@@ -7274,25 +7314,25 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 412:
+	case 416:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4655
+		//line php7/php7.y:4693
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 413:
+	case 417:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4661
+		//line php7/php7.y:4699
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 414:
+	case 418:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4670
+		//line php7/php7.y:4708
 		{
 			yyVAL.node = expr.NewConstFetch(yyDollar[1].node)
 
@@ -7302,79 +7342,47 @@ yydefault:
 			// save comments
 			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 415:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4682
-		{
-			target := node.NewIdentifier(yyDollar[3].token.Value)
-			yyVAL.node = expr.NewClassConstFetch(yyDollar[1].node, target)
-
-			// save position
-			target.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[3].token))
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[3].token))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
-			yylex.(*Parser).setFreeFloating(target, freefloating.Start, yyDollar[3].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 416:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4698
-		{
-			target := node.NewIdentifier(yyDollar[3].token.Value)
-			yyVAL.node = expr.NewClassConstFetch(yyDollar[1].node, target)
-
-			// save position
-			target.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[3].token))
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[3].token))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
-			yylex.(*Parser).setFreeFloating(target, freefloating.Start, yyDollar[3].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 417:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4717
-		{
-			yyVAL.node = yyDollar[1].node
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 418:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4723
-		{
-			yyVAL.node = yyDollar[1].node
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 419:
-		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:4732
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line php7/php7.y:4720
 		{
-			yyVAL.node = nil
+			target := node.NewIdentifier(yyDollar[3].token.Value)
+			yyVAL.node = expr.NewClassConstFetch(yyDollar[1].node, target)
+
+			// save position
+			target.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[3].token))
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[3].token))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
+			yylex.(*Parser).setFreeFloating(target, freefloating.Start, yyDollar[3].token.FreeFloating)
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 420:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4738
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line php7/php7.y:4736
 		{
-			yyVAL.node = yyDollar[1].node
+			target := node.NewIdentifier(yyDollar[3].token.Value)
+			yyVAL.node = expr.NewClassConstFetch(yyDollar[1].node, target)
+
+			// save position
+			target.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[3].token))
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[3].token))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
+			yylex.(*Parser).setFreeFloating(target, freefloating.Start, yyDollar[3].token.FreeFloating)
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 421:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4747
+		//line php7/php7.y:4755
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -7382,27 +7390,23 @@ yydefault:
 		}
 	case 422:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4756
+		//line php7/php7.y:4761
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 423:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4762
+		yyDollar = yyS[yypt-0 : yypt+1]
+		//line php7/php7.y:4770
 		{
-			yyVAL.node = yyDollar[2].node
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, append(yyDollar[1].token.FreeFloating, append(yylex.(*Parser).GetFreeFloatingToken(yyDollar[1].token), (*yyVAL.node.GetFreeFloating())[freefloating.Start]...)...))
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.End, append((*yyVAL.node.GetFreeFloating())[freefloating.End], append(yyDollar[3].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[3].token)...)...))
+			yyVAL.node = nil
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 424:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4772
+		//line php7/php7.y:4776
 		{
 			yyVAL.node = yyDollar[1].node
 
@@ -7410,15 +7414,23 @@ yydefault:
 		}
 	case 425:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4781
+		//line php7/php7.y:4785
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 426:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:4794
+		{
+			yyVAL.node = yyDollar[1].node
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 427:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4787
+		//line php7/php7.y:4800
 		{
 			yyVAL.node = yyDollar[2].node
 
@@ -7426,59 +7438,55 @@ yydefault:
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, append(yyDollar[1].token.FreeFloating, append(yylex.(*Parser).GetFreeFloatingToken(yyDollar[1].token), (*yyVAL.node.GetFreeFloating())[freefloating.Start]...)...))
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.End, append((*yyVAL.node.GetFreeFloating())[freefloating.End], append(yyDollar[3].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[3].token)...)...))
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 427:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4797
-		{
-			yyVAL.node = yyDollar[1].node
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 428:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4806
+		//line php7/php7.y:4810
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 429:
-		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4812
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:4819
 		{
-			yyVAL.node = expr.NewArrayDimFetch(yyDollar[1].node, yyDollar[3].node)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, append(yyDollar[2].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[2].token)...))
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Expr, append(yyDollar[4].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[4].token)...))
+			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 430:
-		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4826
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line php7/php7.y:4825
 		{
-			yyVAL.node = expr.NewArrayDimFetch(yyDollar[1].node, yyDollar[3].node)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token))
+			yyVAL.node = yyDollar[2].node
 
 			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, append(yyDollar[2].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[2].token)...))
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Expr, append(yyDollar[4].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[4].token)...))
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, append(yyDollar[1].token.FreeFloating, append(yylex.(*Parser).GetFreeFloatingToken(yyDollar[1].token), (*yyVAL.node.GetFreeFloating())[freefloating.Start]...)...))
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.End, append((*yyVAL.node.GetFreeFloating())[freefloating.End], append(yyDollar[3].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[3].token)...)...))
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 431:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:4835
+		{
+			yyVAL.node = yyDollar[1].node
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 432:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:4844
+		{
+			yyVAL.node = yyDollar[1].node
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 433:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4840
+		//line php7/php7.y:4850
 		{
 			yyVAL.node = expr.NewArrayDimFetch(yyDollar[1].node, yyDollar[3].node)
 
@@ -7492,9 +7500,41 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 432:
+	case 434:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4854
+		//line php7/php7.y:4864
+		{
+			yyVAL.node = expr.NewArrayDimFetch(yyDollar[1].node, yyDollar[3].node)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, append(yyDollar[2].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[2].token)...))
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Expr, append(yyDollar[4].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[4].token)...))
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 435:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line php7/php7.y:4878
+		{
+			yyVAL.node = expr.NewArrayDimFetch(yyDollar[1].node, yyDollar[3].node)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, append(yyDollar[2].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[2].token)...))
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Expr, append(yyDollar[4].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[4].token)...))
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 436:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line php7/php7.y:4892
 		{
 			yyVAL.node = expr.NewMethodCall(yyDollar[1].node, yyDollar[3].node, yyDollar[4].node.(*node.ArgumentList))
 
@@ -7507,33 +7547,33 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 433:
+	case 437:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4867
+		//line php7/php7.y:4905
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 434:
+	case 438:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4876
+		//line php7/php7.y:4914
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 435:
+	case 439:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4882
+		//line php7/php7.y:4920
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 436:
+	case 440:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4888
+		//line php7/php7.y:4926
 		{
 			yyVAL.node = expr.NewPropertyFetch(yyDollar[1].node, yyDollar[3].node)
 
@@ -7546,9 +7586,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 437:
+	case 441:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4904
+		//line php7/php7.y:4942
 		{
 			name := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[1].token.Value, isDollar))
 			yyVAL.node = expr.NewVariable(name)
@@ -7563,9 +7603,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 438:
+	case 442:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4919
+		//line php7/php7.y:4957
 		{
 			yyVAL.node = expr.NewVariable(yyDollar[3].node)
 
@@ -7580,9 +7620,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 439:
+	case 443:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:4934
+		//line php7/php7.y:4972
 		{
 			yyVAL.node = expr.NewVariable(yyDollar[2].node)
 
@@ -7593,81 +7633,81 @@ yydefault:
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Dollar, yylex.(*Parser).GetFreeFloatingToken(yyDollar[1].token))
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 440:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4950
-		{
-			yyVAL.node = expr.NewStaticPropertyFetch(yyDollar[1].node, yyDollar[3].node)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[3].node))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 441:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:4963
-		{
-			yyVAL.node = expr.NewStaticPropertyFetch(yyDollar[1].node, yyDollar[3].node)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[3].node))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 442:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:4979
-		{
-			yyVAL.node = yyDollar[1].node
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 443:
-		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4985
-		{
-			yyVAL.node = expr.NewArrayDimFetch(yyDollar[1].node, yyDollar[3].node)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, append(yyDollar[2].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[2].token)...))
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Expr, append(yyDollar[4].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[4].token)...))
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 444:
-		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:4999
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line php7/php7.y:4988
 		{
-			yyVAL.node = expr.NewArrayDimFetch(yyDollar[1].node, yyDollar[3].node)
+			yyVAL.node = expr.NewStaticPropertyFetch(yyDollar[1].node, yyDollar[3].node)
 
 			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token))
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[3].node))
 
 			// save comments
 			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, append(yyDollar[2].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[2].token)...))
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Expr, append(yyDollar[4].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[4].token)...))
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 445:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5013
+		//line php7/php7.y:5001
+		{
+			yyVAL.node = expr.NewStaticPropertyFetch(yyDollar[1].node, yyDollar[3].node)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[3].node))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Name, yyDollar[2].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 446:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:5017
+		{
+			yyVAL.node = yyDollar[1].node
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 447:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line php7/php7.y:5023
+		{
+			yyVAL.node = expr.NewArrayDimFetch(yyDollar[1].node, yyDollar[3].node)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, append(yyDollar[2].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[2].token)...))
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Expr, append(yyDollar[4].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[4].token)...))
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 448:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line php7/php7.y:5037
+		{
+			yyVAL.node = expr.NewArrayDimFetch(yyDollar[1].node, yyDollar[3].node)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, append(yyDollar[2].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[2].token)...))
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Expr, append(yyDollar[4].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[4].token)...))
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 449:
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line php7/php7.y:5051
 		{
 			yyVAL.node = expr.NewPropertyFetch(yyDollar[1].node, yyDollar[3].node)
 
@@ -7678,75 +7718,41 @@ yydefault:
 			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, yyDollar[2].token.FreeFloating)
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 446:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5026
-		{
-			yyVAL.node = expr.NewStaticPropertyFetch(yyDollar[1].node, yyDollar[3].node)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[3].node))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, yyDollar[2].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 447:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5039
-		{
-			yyVAL.node = expr.NewStaticPropertyFetch(yyDollar[1].node, yyDollar[3].node)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[3].node))
-
-			// save comments
-			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, yyDollar[2].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 448:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5055
-		{
-			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
-
-			// save position
-			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 449:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5067
-		{
-			yyVAL.node = yyDollar[2].node
-
-			// save comments
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, append(yyDollar[1].token.FreeFloating, append(yylex.(*Parser).GetFreeFloatingToken(yyDollar[1].token), (*yyVAL.node.GetFreeFloating())[freefloating.Start]...)...))
-			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.End, append((*yyVAL.node.GetFreeFloating())[freefloating.End], append(yyDollar[3].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[3].token)...)...))
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 450:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5077
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line php7/php7.y:5064
 		{
-			yyVAL.node = yyDollar[1].node
+			yyVAL.node = expr.NewStaticPropertyFetch(yyDollar[1].node, yyDollar[3].node)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[3].node))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, yyDollar[2].token.FreeFloating)
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 451:
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line php7/php7.y:5077
+		{
+			yyVAL.node = expr.NewStaticPropertyFetch(yyDollar[1].node, yyDollar[3].node)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition(yyDollar[1].node, yyDollar[3].node))
+
+			// save comments
+			yylex.(*Parser).MoveFreeFloating(yyDollar[1].node, yyVAL.node)
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Var, yyDollar[2].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 452:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5086
+		//line php7/php7.y:5093
 		{
 			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
 
@@ -7758,9 +7764,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 452:
+	case 453:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5098
+		//line php7/php7.y:5105
 		{
 			yyVAL.node = yyDollar[2].node
 
@@ -7768,43 +7774,77 @@ yydefault:
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, append(yyDollar[1].token.FreeFloating, append(yylex.(*Parser).GetFreeFloatingToken(yyDollar[1].token), (*yyVAL.node.GetFreeFloating())[freefloating.Start]...)...))
 			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.End, append((*yyVAL.node.GetFreeFloating())[freefloating.End], append(yyDollar[3].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[3].token)...)...))
 
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 453:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5108
-		{
-			yyVAL.node = yyDollar[1].node
-
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
 	case 454:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5117
-		{
-			yyVAL.list = yyDollar[1].list
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 455:
-		yyDollar = yyS[yypt-0 : yypt+1]
-		//line php7/php7.y:5126
-		{
-			yyVAL.node = expr.NewArrayItem(nil, nil)
-
-			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
-		}
-	case 456:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5132
+		//line php7/php7.y:5115
 		{
 			yyVAL.node = yyDollar[1].node
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 457:
+	case 455:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:5124
+		{
+			yyVAL.node = node.NewIdentifier(yyDollar[1].token.Value)
+
+			// save position
+			yyVAL.node.SetPosition(yylex.(*Parser).positionBuilder.NewTokenPosition(yyDollar[1].token))
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, yyDollar[1].token.FreeFloating)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 456:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5141
+		//line php7/php7.y:5136
+		{
+			yyVAL.node = yyDollar[2].node
+
+			// save comments
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.Start, append(yyDollar[1].token.FreeFloating, append(yylex.(*Parser).GetFreeFloatingToken(yyDollar[1].token), (*yyVAL.node.GetFreeFloating())[freefloating.Start]...)...))
+			yylex.(*Parser).setFreeFloating(yyVAL.node, freefloating.End, append((*yyVAL.node.GetFreeFloating())[freefloating.End], append(yyDollar[3].token.FreeFloating, yylex.(*Parser).GetFreeFloatingToken(yyDollar[3].token)...)...))
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 457:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:5146
+		{
+			yyVAL.node = yyDollar[1].node
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 458:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:5155
+		{
+			yyVAL.list = yyDollar[1].list
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 459:
+		yyDollar = yyS[yypt-0 : yypt+1]
+		//line php7/php7.y:5164
+		{
+			yyVAL.node = expr.NewArrayItem(nil, nil)
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 460:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line php7/php7.y:5170
+		{
+			yyVAL.node = yyDollar[1].node
+
+			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+		}
+	case 461:
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line php7/php7.y:5179
 		{
 			if len(yyDollar[1].list) == 0 {
 				yyDollar[1].list = []node.Node{expr.NewArrayItem(nil, nil)}
@@ -7817,9 +7857,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 458:
+	case 462:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5154
+		//line php7/php7.y:5192
 		{
 			if yyDollar[1].node.(*expr.ArrayItem).Key == nil && yyDollar[1].node.(*expr.ArrayItem).Val == nil {
 				yyVAL.list = []node.Node{}
@@ -7829,9 +7869,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 459:
+	case 463:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5167
+		//line php7/php7.y:5205
 		{
 			yyVAL.node = expr.NewArrayItem(yyDollar[1].node, yyDollar[3].node)
 
@@ -7844,9 +7884,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 460:
+	case 464:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5180
+		//line php7/php7.y:5218
 		{
 			yyVAL.node = expr.NewArrayItem(nil, yyDollar[1].node)
 
@@ -7858,9 +7898,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 461:
+	case 465:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:5192
+		//line php7/php7.y:5230
 		{
 			reference := expr.NewReference(yyDollar[4].node)
 			yyVAL.node = expr.NewArrayItem(yyDollar[1].node, reference)
@@ -7876,9 +7916,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 462:
+	case 466:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:5208
+		//line php7/php7.y:5246
 		{
 			reference := expr.NewReference(yyDollar[2].node)
 			yyVAL.node = expr.NewArrayItem(nil, reference)
@@ -7892,9 +7932,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 463:
+	case 467:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:5222
+		//line php7/php7.y:5260
 		{
 			// TODO: Cannot use list() as standalone expression
 			listNode := expr.NewList(yyDollar[5].list)
@@ -7913,9 +7953,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 464:
+	case 468:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:5241
+		//line php7/php7.y:5279
 		{
 			// TODO: Cannot use list() as standalone expression
 			listNode := expr.NewList(yyDollar[3].list)
@@ -7932,17 +7972,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 465:
+	case 469:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:5261
+		//line php7/php7.y:5299
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[2].node)
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 466:
+	case 470:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:5267
+		//line php7/php7.y:5305
 		{
 			encapsed := scalar.NewEncapsedStringPart(yyDollar[2].token.Value)
 			yyVAL.list = append(yyDollar[1].list, encapsed)
@@ -7955,17 +7995,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 467:
+	case 471:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5280
+		//line php7/php7.y:5318
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 468:
+	case 472:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:5286
+		//line php7/php7.y:5324
 		{
 			encapsed := scalar.NewEncapsedStringPart(yyDollar[1].token.Value)
 			yyVAL.list = []node.Node{encapsed, yyDollar[2].node}
@@ -7978,9 +8018,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 469:
+	case 473:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5302
+		//line php7/php7.y:5340
 		{
 			name := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[1].token.Value, isDollar))
 			yyVAL.node = expr.NewVariable(name)
@@ -7995,9 +8035,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 470:
+	case 474:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:5317
+		//line php7/php7.y:5355
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[1].token.Value, isDollar))
 			variable := expr.NewVariable(identifier)
@@ -8015,9 +8055,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 471:
+	case 475:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5335
+		//line php7/php7.y:5373
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[1].token.Value, isDollar))
 			variable := expr.NewVariable(identifier)
@@ -8037,9 +8077,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 472:
+	case 476:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5355
+		//line php7/php7.y:5393
 		{
 			variable := expr.NewVariable(yyDollar[2].node)
 
@@ -8054,9 +8094,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 473:
+	case 477:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5370
+		//line php7/php7.y:5408
 		{
 			name := node.NewIdentifier(yyDollar[2].token.Value)
 			variable := expr.NewVariable(name)
@@ -8073,9 +8113,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 474:
+	case 478:
 		yyDollar = yyS[yypt-6 : yypt+1]
-		//line php7/php7.y:5387
+		//line php7/php7.y:5425
 		{
 			identifier := node.NewIdentifier(yyDollar[2].token.Value)
 			variable := expr.NewVariable(identifier)
@@ -8094,9 +8134,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 475:
+	case 479:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5406
+		//line php7/php7.y:5444
 		{
 			yyVAL.node = yyDollar[2].node
 
@@ -8106,9 +8146,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 476:
+	case 480:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5419
+		//line php7/php7.y:5457
 		{
 			yyVAL.node = scalar.NewString(yyDollar[1].token.Value)
 
@@ -8120,9 +8160,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 477:
+	case 481:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5431
+		//line php7/php7.y:5469
 		{
 			// TODO: add option to handle 64 bit integer
 			if _, err := strconv.Atoi(yyDollar[1].token.Value); err == nil {
@@ -8139,9 +8179,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 478:
+	case 482:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:5448
+		//line php7/php7.y:5486
 		{
 			var lnumber *scalar.Lnumber
 			// TODO: add option to handle 64 bit integer
@@ -8167,9 +8207,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 479:
+	case 483:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5474
+		//line php7/php7.y:5512
 		{
 			identifier := node.NewIdentifier(strings.TrimLeftFunc(yyDollar[1].token.Value, isDollar))
 			yyVAL.node = expr.NewVariable(identifier)
@@ -8184,9 +8224,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 480:
+	case 484:
 		yyDollar = yyS[yypt-5 : yypt+1]
-		//line php7/php7.y:5492
+		//line php7/php7.y:5530
 		{
 			yyVAL.node = expr.NewIsset(yyDollar[3].list)
 
@@ -8204,9 +8244,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 481:
+	case 485:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:5510
+		//line php7/php7.y:5548
 		{
 			yyVAL.node = expr.NewEmpty(yyDollar[3].node)
 
@@ -8220,9 +8260,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 482:
+	case 486:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:5524
+		//line php7/php7.y:5562
 		{
 			yyVAL.node = expr.NewInclude(yyDollar[2].node)
 
@@ -8234,9 +8274,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 483:
+	case 487:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:5536
+		//line php7/php7.y:5574
 		{
 			yyVAL.node = expr.NewIncludeOnce(yyDollar[2].node)
 
@@ -8248,9 +8288,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 484:
+	case 488:
 		yyDollar = yyS[yypt-4 : yypt+1]
-		//line php7/php7.y:5548
+		//line php7/php7.y:5586
 		{
 			yyVAL.node = expr.NewEval(yyDollar[3].node)
 
@@ -8264,9 +8304,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 485:
+	case 489:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:5562
+		//line php7/php7.y:5600
 		{
 			yyVAL.node = expr.NewRequire(yyDollar[2].node)
 
@@ -8278,9 +8318,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 486:
+	case 490:
 		yyDollar = yyS[yypt-2 : yypt+1]
-		//line php7/php7.y:5574
+		//line php7/php7.y:5612
 		{
 			yyVAL.node = expr.NewRequireOnce(yyDollar[2].node)
 
@@ -8292,17 +8332,17 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 487:
+	case 491:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5589
+		//line php7/php7.y:5627
 		{
 			yyVAL.list = []node.Node{yyDollar[1].node}
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 488:
+	case 492:
 		yyDollar = yyS[yypt-3 : yypt+1]
-		//line php7/php7.y:5595
+		//line php7/php7.y:5633
 		{
 			yyVAL.list = append(yyDollar[1].list, yyDollar[3].node)
 
@@ -8311,9 +8351,9 @@ yydefault:
 
 			yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
 		}
-	case 489:
+	case 493:
 		yyDollar = yyS[yypt-1 : yypt+1]
-		//line php7/php7.y:5607
+		//line php7/php7.y:5645
 		{
 			yyVAL.node = yyDollar[1].node
 
diff --git a/php7/php7.y b/php7/php7.y
index e18c7b5..7e4419e 100644
--- a/php7/php7.y
+++ b/php7/php7.y
@@ -271,6 +271,7 @@ import (
 %type <node> switch_case_list
 %type <node> method_body
 %type <node> foreach_statement for_statement while_statement
+%type <node> inline_function
 %type <ClassExtends> extends_from
 %type <ClassImplements> implements_list
 %type <InterfaceExtends> interface_extends_list
@@ -318,7 +319,7 @@ reserved_non_modifiers:
     | T_THROW {$$=$1} | T_USE {$$=$1} | T_INSTEADOF {$$=$1} | T_GLOBAL {$$=$1} | T_VAR {$$=$1} | T_UNSET {$$=$1} | T_ISSET {$$=$1} | T_EMPTY {$$=$1} | T_CONTINUE {$$=$1} | T_GOTO {$$=$1} 
     | T_FUNCTION {$$=$1} | T_CONST {$$=$1} | T_RETURN {$$=$1} | T_PRINT {$$=$1} | T_YIELD {$$=$1} | T_LIST {$$=$1} | T_SWITCH {$$=$1} | T_ENDSWITCH {$$=$1} | T_CASE {$$=$1} | T_DEFAULT {$$=$1} | T_BREAK {$$=$1} 
     | T_ARRAY {$$=$1} | T_CALLABLE {$$=$1} | T_EXTENDS {$$=$1} | T_IMPLEMENTS {$$=$1} | T_NAMESPACE {$$=$1} | T_TRAIT {$$=$1} | T_INTERFACE {$$=$1} | T_CLASS {$$=$1} 
-    | T_CLASS_C {$$=$1} | T_TRAIT_C {$$=$1} | T_FUNC_C {$$=$1} | T_METHOD_C {$$=$1} | T_LINE {$$=$1} | T_FILE {$$=$1} | T_DIR {$$=$1} | T_NS_C {$$=$1} 
+    | T_CLASS_C {$$=$1} | T_TRAIT_C {$$=$1} | T_FUNC_C {$$=$1} | T_METHOD_C {$$=$1} | T_LINE {$$=$1} | T_FILE {$$=$1} | T_DIR {$$=$1} | T_NS_C {$$=$1} | T_FN {$$=$1}
 ;
 
 semi_reserved:
@@ -3398,6 +3399,19 @@ expr_without_variable:
                 yylex.(*Parser).MoveFreeFloating($1, $$)
                 yylex.(*Parser).setFreeFloating($$, freefloating.Var, $2.FreeFloating)
 
+                yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+            }
+    |   variable T_COALESCE_EQUAL expr
+            {
+                $$ = assign.NewCoalesce($1, $3)
+
+                // save position
+                $$.SetPosition(yylex.(*Parser).positionBuilder.NewNodesPosition($1, $3))
+
+                // save comments
+                yylex.(*Parser).MoveFreeFloating($1, $$)
+                yylex.(*Parser).setFreeFloating($$, freefloating.Var, $2.FreeFloating)
+
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
     |   variable T_INC
@@ -4122,7 +4136,36 @@ expr_without_variable:
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
-    |   T_FUNCTION returns_ref backup_doc_comment '(' parameter_list ')' lexical_vars return_type '{' inner_statement_list '}'
+    |   inline_function
+            {
+                $$ = $1;
+
+                yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+            }
+    |   T_STATIC inline_function
+            {
+                $$ = $2;
+
+                switch n := $$.(type) {
+                case *expr.Closure :
+                    n.Static = true;
+                case *expr.ArrowFunction :
+                    n.Static = true;
+                };
+
+                // save position
+                $$.SetPosition(yylex.(*Parser).positionBuilder.NewTokenNodePosition($1, $2))
+
+                // save comments
+                yylex.(*Parser).setFreeFloating($$, freefloating.Static, (*$$.GetFreeFloating())[freefloating.Start]); delete((*$$.GetFreeFloating()), freefloating.Start)
+                yylex.(*Parser).setFreeFloating($$, freefloating.Start, $1.FreeFloating);
+
+                yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
+            }
+;
+
+inline_function:
+        T_FUNCTION returns_ref backup_doc_comment '(' parameter_list ')' lexical_vars return_type '{' inner_statement_list '}'
             {
                 $$ = expr.NewClosure($5, $7, $8, $10, false, $2 != nil, $3)
 
@@ -4154,36 +4197,31 @@ expr_without_variable:
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
-    |   T_STATIC T_FUNCTION returns_ref backup_doc_comment '(' parameter_list ')' lexical_vars return_type '{' inner_statement_list '}'
+    |   T_FN returns_ref '(' parameter_list ')' return_type backup_doc_comment T_DOUBLE_ARROW expr
             {
-                $$ = expr.NewClosure($6, $8, $9, $11, true, $3 != nil, $4)
+                $$ = expr.NewArrowFunction($4, $6, $9, false, $2 != nil, $7)
 
                 // save position
-                $$.SetPosition(yylex.(*Parser).positionBuilder.NewTokensPosition($1, $12))
+                $$.SetPosition(yylex.(*Parser).positionBuilder.NewTokenNodePosition($1, $9))
                 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, freefloating.Start, $1.FreeFloating)
-                yylex.(*Parser).setFreeFloating($$, freefloating.Static, $2.FreeFloating)
-                if $3 == nil {
-                    yylex.(*Parser).setFreeFloating($$, freefloating.Function, $5.FreeFloating)
-                } else {
+                if $2 == nil {
                     yylex.(*Parser).setFreeFloating($$, freefloating.Function, $3.FreeFloating)
-                    yylex.(*Parser).setFreeFloating($$, freefloating.Ampersand, $5.FreeFloating)
-                }
-                yylex.(*Parser).setFreeFloating($$, freefloating.ParameterList, $7.FreeFloating)
-                if $9 != nil {
-                    yylex.(*Parser).setFreeFloating($$, freefloating.LexicalVars, (*$9.GetFreeFloating())[freefloating.Colon]); delete((*$9.GetFreeFloating()), freefloating.Colon)
-                }
-                yylex.(*Parser).setFreeFloating($$, freefloating.ReturnType, $10.FreeFloating)
-                yylex.(*Parser).setFreeFloating($$, freefloating.Stmts, $12.FreeFloating)
+                } else {
+                    yylex.(*Parser).setFreeFloating($$, freefloating.Function, $2.FreeFloating)
+                    yylex.(*Parser).setFreeFloating($$, freefloating.Ampersand, $3.FreeFloating)
+                };
+                yylex.(*Parser).setFreeFloating($$, freefloating.ParameterList, $5.FreeFloating)
+                if $6 != nil {
+                    yylex.(*Parser).setFreeFloating($$, freefloating.Params, (*$6.GetFreeFloating())[freefloating.Colon]); delete((*$6.GetFreeFloating()), freefloating.Colon)
+                };
+                yylex.(*Parser).setFreeFloating($$, freefloating.ReturnType, $8.FreeFloating)
 
                 // normalize
-                if $9 == nil {
-                    yylex.(*Parser).setFreeFloating($$, freefloating.LexicalVars, (*$$.GetFreeFloating())[freefloating.ReturnType]); delete((*$$.GetFreeFloating()), freefloating.ReturnType)
-                }
-                if $8 == nil {
-                    yylex.(*Parser).setFreeFloating($$, freefloating.Params, (*$$.GetFreeFloating())[freefloating.LexicalVarList]); delete((*$$.GetFreeFloating()), freefloating.LexicalVarList)
-                }
+                if $6 == nil {
+                    yylex.(*Parser).setFreeFloating($$, freefloating.Params, (*$$.GetFreeFloating())[freefloating.ReturnType]); delete((*$$.GetFreeFloating()), freefloating.ReturnType)
+                };
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
diff --git a/printer/printer.go b/printer/printer.go
index e0c3f26..0ca8cf3 100644
--- a/printer/printer.go
+++ b/printer/printer.go
@@ -135,6 +135,8 @@ func (p *Printer) printNode(n node.Node) {
 		p.printAssignBitwiseOr(n)
 	case *assign.BitwiseXor:
 		p.printAssignBitwiseXor(n)
+	case *assign.Coalesce:
+		p.printAssignCoalesce(n)
 	case *assign.Concat:
 		p.printAssignConcat(n)
 	case *assign.Div:
@@ -236,6 +238,8 @@ func (p *Printer) printNode(n node.Node) {
 		p.printExprArrayItem(n)
 	case *expr.Array:
 		p.printExprArray(n)
+	case *expr.ArrowFunction:
+		p.printExprArrowFunction(n)
 	case *expr.BitwiseNot:
 		p.printExprBitwiseNot(n)
 	case *expr.BooleanNot:
@@ -712,6 +716,17 @@ func (p *Printer) printAssignBitwiseXor(n node.Node) {
 	p.printFreeFloating(nn, freefloating.End)
 }
 
+func (p *Printer) printAssignCoalesce(n node.Node) {
+	nn := n.(*assign.Coalesce)
+	p.printFreeFloating(nn, freefloating.Start)
+	p.Print(nn.Variable)
+	p.printFreeFloating(nn, freefloating.Var)
+	io.WriteString(p.w, "??=")
+	p.Print(nn.Expression)
+
+	p.printFreeFloating(nn, freefloating.End)
+}
+
 func (p *Printer) printAssignConcat(n node.Node) {
 	nn := n.(*assign.Concat)
 	p.printFreeFloating(nn, freefloating.Start)
@@ -1313,6 +1328,45 @@ func (p *Printer) printExprArray(n node.Node) {
 	p.printFreeFloating(nn, freefloating.End)
 }
 
+func (p *Printer) printExprArrowFunction(n node.Node) {
+	nn := n.(*expr.ArrowFunction)
+	p.printFreeFloating(nn, freefloating.Start)
+
+	if nn.Static {
+		io.WriteString(p.w, "static")
+	}
+	p.printFreeFloating(nn, freefloating.Static)
+	if nn.Static && n.GetFreeFloating().IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+
+	io.WriteString(p.w, "fn")
+	p.printFreeFloating(nn, freefloating.Function)
+
+	if nn.ReturnsRef {
+		io.WriteString(p.w, "&")
+	}
+	p.printFreeFloating(nn, freefloating.Ampersand)
+
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Params)
+	p.printFreeFloating(nn, freefloating.ParameterList)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, freefloating.Params)
+
+	if nn.ReturnType != nil {
+		io.WriteString(p.w, ":")
+		p.Print(nn.ReturnType)
+	}
+	p.printFreeFloating(nn, freefloating.ReturnType)
+
+	io.WriteString(p.w, "=>")
+
+	p.printNode(nn.Expr)
+
+	p.printFreeFloating(nn, freefloating.End)
+}
+
 func (p *Printer) printExprBitwiseNot(n node.Node) {
 	nn := n.(*expr.BitwiseNot)
 	p.printFreeFloating(nn, freefloating.Start)
diff --git a/printer/printer_parsed_php7_test.go b/printer/printer_parsed_php7_test.go
index 09f2fc2..7bdccab 100644
--- a/printer/printer_parsed_php7_test.go
+++ b/printer/printer_parsed_php7_test.go
@@ -270,6 +270,7 @@ func TestParseAndPrintAssign(t *testing.T) {
 	$a &= $b ;
 	$a |= $b ;
 	$a ^= $b ;
+	$a ??= $b ;
 	$a .= $b ;
 	$a /= $b ;
 	$a -= $b ;
@@ -482,6 +483,18 @@ func TestParseAndPrintClosure(t *testing.T) {
 	}
 }
 
+func TestParseAndPrintArrowFunction(t *testing.T) {
+	src := `<?php
+	$a = static fn & ( $b ) : void => $c ;
+	`
+
+	actual := print(parse(src))
+
+	if src != actual {
+		t.Errorf("\nexpected: %s\ngot: %s\n", src, actual)
+	}
+}
+
 func TestParseAndPrintConstFetch(t *testing.T) {
 	src := `<?php
 	null ;
diff --git a/printer/printer_test.go b/printer/printer_test.go
index 1ee3c8d..946d062 100644
--- a/printer/printer_test.go
+++ b/printer/printer_test.go
@@ -586,6 +586,27 @@ func TestPrinterPrintAssignBitwiseXor(t *testing.T) {
 	}
 }
 
+func TestPrinterPrintAssignCoalesce(t *testing.T) {
+	o := bytes.NewBufferString("")
+
+	p := printer.NewPrinter(o)
+	p.Print(&assign.Coalesce{
+		Variable: &expr.Variable{
+			VarName: &node.Identifier{Value: "a"},
+		},
+		Expression: &expr.Variable{
+			VarName: &node.Identifier{Value: "b"},
+		},
+	})
+
+	expected := `$a??=$b`
+	actual := o.String()
+
+	if expected != actual {
+		t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
+	}
+}
+
 func TestPrinterPrintAssignConcat(t *testing.T) {
 	o := bytes.NewBufferString("")
 
@@ -1706,6 +1727,40 @@ func TestPrinterPrintExprClosure(t *testing.T) {
 	}
 }
 
+func TestPrinterPrintExprArrowFunction(t *testing.T) {
+	o := bytes.NewBufferString("")
+
+	p := printer.NewPrinter(o)
+	p.Print(&stmt.Expression{
+		Expr: &expr.ArrowFunction{
+			Static:     true,
+			ReturnsRef: true,
+			Params: []node.Node{
+				&node.Parameter{
+					ByRef:    true,
+					Variadic: false,
+					Variable: &expr.Variable{
+						VarName: &node.Identifier{Value: "var"},
+					},
+				},
+			},
+			ReturnType: &name.FullyQualified{
+				Parts: []node.Node{&name.NamePart{Value: "Foo"}},
+			},
+			Expr: &expr.Variable{
+				VarName: &node.Identifier{Value: "a"},
+			},
+		},
+	})
+
+	expected := `static fn&(&$var):\Foo=>$a;`
+	actual := o.String()
+
+	if expected != actual {
+		t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
+	}
+}
+
 func TestPrinterPrintExprConstFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
diff --git a/scanner/scanner.go b/scanner/scanner.go
index 9ef14a4..80fb2c1 100644
--- a/scanner/scanner.go
+++ b/scanner/scanner.go
@@ -16,19 +16,19 @@ const lexer_error int = 0
 
 const lexer_en_main int = 110
 const lexer_en_php int = 117
-const lexer_en_property int = 463
-const lexer_en_nowdoc int = 469
-const lexer_en_heredoc int = 472
-const lexer_en_backqote int = 478
-const lexer_en_template_string int = 484
-const lexer_en_heredoc_end int = 490
-const lexer_en_string_var int = 492
-const lexer_en_string_var_index int = 497
-const lexer_en_string_var_name int = 507
-const lexer_en_halt_compiller_open_parenthesis int = 509
-const lexer_en_halt_compiller_close_parenthesis int = 513
-const lexer_en_halt_compiller_close_semicolon int = 517
-const lexer_en_halt_compiller_end int = 521
+const lexer_en_property int = 464
+const lexer_en_nowdoc int = 470
+const lexer_en_heredoc int = 473
+const lexer_en_backqote int = 479
+const lexer_en_template_string int = 485
+const lexer_en_heredoc_end int = 491
+const lexer_en_string_var int = 493
+const lexer_en_string_var_index int = 498
+const lexer_en_string_var_name int = 508
+const lexer_en_halt_compiller_open_parenthesis int = 510
+const lexer_en_halt_compiller_close_parenthesis int = 514
+const lexer_en_halt_compiller_close_semicolon int = 518
+const lexer_en_halt_compiller_end int = 522
 
 //line scanner/scanner.rl:17
 
@@ -383,12 +383,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st171
 		case 172:
 			goto st172
+		case 173:
+			goto st173
 		case 90:
 			goto st90
 		case 91:
 			goto st91
-		case 173:
-			goto st173
 		case 174:
 			goto st174
 		case 175:
@@ -827,6 +827,8 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st391
 		case 392:
 			goto st392
+		case 393:
+			goto st393
 		case 92:
 			goto st92
 		case 93:
@@ -839,8 +841,6 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st96
 		case 97:
 			goto st97
-		case 393:
-			goto st393
 		case 394:
 			goto st394
 		case 395:
@@ -985,30 +985,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st464
 		case 465:
 			goto st465
-		case 98:
-			goto st98
 		case 466:
 			goto st466
+		case 98:
+			goto st98
 		case 467:
 			goto st467
 		case 468:
 			goto st468
 		case 469:
 			goto st469
-		case 0:
-			goto st0
 		case 470:
 			goto st470
+		case 0:
+			goto st0
 		case 471:
 			goto st471
 		case 472:
 			goto st472
 		case 473:
 			goto st473
-		case 99:
-			goto st99
 		case 474:
 			goto st474
+		case 99:
+			goto st99
 		case 475:
 			goto st475
 		case 476:
@@ -1019,10 +1019,10 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st478
 		case 479:
 			goto st479
-		case 100:
-			goto st100
 		case 480:
 			goto st480
+		case 100:
+			goto st100
 		case 481:
 			goto st481
 		case 482:
@@ -1033,10 +1033,10 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st484
 		case 485:
 			goto st485
-		case 101:
-			goto st101
 		case 486:
 			goto st486
+		case 101:
+			goto st101
 		case 487:
 			goto st487
 		case 488:
@@ -1055,10 +1055,10 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st494
 		case 495:
 			goto st495
-		case 102:
-			goto st102
 		case 496:
 			goto st496
+		case 102:
+			goto st102
 		case 497:
 			goto st497
 		case 498:
@@ -1073,60 +1073,62 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st502
 		case 503:
 			goto st503
+		case 504:
+			goto st504
 		case 103:
 			goto st103
 		case 104:
 			goto st104
-		case 504:
-			goto st504
-		case 105:
-			goto st105
 		case 505:
 			goto st505
+		case 105:
+			goto st105
 		case 506:
 			goto st506
 		case 507:
 			goto st507
 		case 508:
 			goto st508
-		case 106:
-			goto st106
 		case 509:
 			goto st509
+		case 106:
+			goto st106
 		case 510:
 			goto st510
 		case 511:
 			goto st511
-		case 107:
-			goto st107
 		case 512:
 			goto st512
+		case 107:
+			goto st107
 		case 513:
 			goto st513
 		case 514:
 			goto st514
 		case 515:
 			goto st515
-		case 108:
-			goto st108
 		case 516:
 			goto st516
+		case 108:
+			goto st108
 		case 517:
 			goto st517
 		case 518:
 			goto st518
 		case 519:
 			goto st519
-		case 109:
-			goto st109
 		case 520:
 			goto st520
+		case 109:
+			goto st109
 		case 521:
 			goto st521
 		case 522:
 			goto st522
 		case 523:
 			goto st523
+		case 524:
+			goto st524
 		}
 
 		if (lex.p)++; (lex.p) == (lex.pe) {
@@ -1438,12 +1440,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st_case_171
 		case 172:
 			goto st_case_172
+		case 173:
+			goto st_case_173
 		case 90:
 			goto st_case_90
 		case 91:
 			goto st_case_91
-		case 173:
-			goto st_case_173
 		case 174:
 			goto st_case_174
 		case 175:
@@ -1882,6 +1884,8 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st_case_391
 		case 392:
 			goto st_case_392
+		case 393:
+			goto st_case_393
 		case 92:
 			goto st_case_92
 		case 93:
@@ -1894,8 +1898,6 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st_case_96
 		case 97:
 			goto st_case_97
-		case 393:
-			goto st_case_393
 		case 394:
 			goto st_case_394
 		case 395:
@@ -2040,30 +2042,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st_case_464
 		case 465:
 			goto st_case_465
-		case 98:
-			goto st_case_98
 		case 466:
 			goto st_case_466
+		case 98:
+			goto st_case_98
 		case 467:
 			goto st_case_467
 		case 468:
 			goto st_case_468
 		case 469:
 			goto st_case_469
-		case 0:
-			goto st_case_0
 		case 470:
 			goto st_case_470
+		case 0:
+			goto st_case_0
 		case 471:
 			goto st_case_471
 		case 472:
 			goto st_case_472
 		case 473:
 			goto st_case_473
-		case 99:
-			goto st_case_99
 		case 474:
 			goto st_case_474
+		case 99:
+			goto st_case_99
 		case 475:
 			goto st_case_475
 		case 476:
@@ -2074,10 +2076,10 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st_case_478
 		case 479:
 			goto st_case_479
-		case 100:
-			goto st_case_100
 		case 480:
 			goto st_case_480
+		case 100:
+			goto st_case_100
 		case 481:
 			goto st_case_481
 		case 482:
@@ -2088,10 +2090,10 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st_case_484
 		case 485:
 			goto st_case_485
-		case 101:
-			goto st_case_101
 		case 486:
 			goto st_case_486
+		case 101:
+			goto st_case_101
 		case 487:
 			goto st_case_487
 		case 488:
@@ -2110,10 +2112,10 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st_case_494
 		case 495:
 			goto st_case_495
-		case 102:
-			goto st_case_102
 		case 496:
 			goto st_case_496
+		case 102:
+			goto st_case_102
 		case 497:
 			goto st_case_497
 		case 498:
@@ -2128,60 +2130,62 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st_case_502
 		case 503:
 			goto st_case_503
+		case 504:
+			goto st_case_504
 		case 103:
 			goto st_case_103
 		case 104:
 			goto st_case_104
-		case 504:
-			goto st_case_504
-		case 105:
-			goto st_case_105
 		case 505:
 			goto st_case_505
+		case 105:
+			goto st_case_105
 		case 506:
 			goto st_case_506
 		case 507:
 			goto st_case_507
 		case 508:
 			goto st_case_508
-		case 106:
-			goto st_case_106
 		case 509:
 			goto st_case_509
+		case 106:
+			goto st_case_106
 		case 510:
 			goto st_case_510
 		case 511:
 			goto st_case_511
-		case 107:
-			goto st_case_107
 		case 512:
 			goto st_case_512
+		case 107:
+			goto st_case_107
 		case 513:
 			goto st_case_513
 		case 514:
 			goto st_case_514
 		case 515:
 			goto st_case_515
-		case 108:
-			goto st_case_108
 		case 516:
 			goto st_case_516
+		case 108:
+			goto st_case_108
 		case 517:
 			goto st_case_517
 		case 518:
 			goto st_case_518
 		case 519:
 			goto st_case_519
-		case 109:
-			goto st_case_109
 		case 520:
 			goto st_case_520
+		case 109:
+			goto st_case_109
 		case 521:
 			goto st_case_521
 		case 522:
 			goto st_case_522
 		case 523:
 			goto st_case_523
+		case 524:
+			goto st_case_524
 		}
 		goto st_out
 	tr0:
@@ -2283,7 +2287,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 //line NONE:1
 		lex.ts = (lex.p)
 
-//line scanner/scanner.go:2281
+//line scanner/scanner.go:2285
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st112
@@ -2300,7 +2304,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof111
 		}
 	st_case_111:
-//line scanner/scanner.go:2298
+//line scanner/scanner.go:2302
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st112
@@ -2317,7 +2321,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof112
 		}
 	st_case_112:
-//line scanner/scanner.go:2315
+//line scanner/scanner.go:2319
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr166
@@ -2334,7 +2338,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof113
 		}
 	st_case_113:
-//line scanner/scanner.go:2332
+//line scanner/scanner.go:2336
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st112
@@ -2368,7 +2372,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof115
 		}
 	st_case_115:
-//line scanner/scanner.go:2366
+//line scanner/scanner.go:2370
 		switch lex.data[(lex.p)] {
 		case 61:
 			goto tr170
@@ -2812,7 +2816,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_GLOBAL
+				tok = T_FN
 				{
 					(lex.p)++
 					goto _out
@@ -2822,7 +2826,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_GOTO
+				tok = T_GLOBAL
 				{
 					(lex.p)++
 					goto _out
@@ -2832,7 +2836,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_IF
+				tok = T_GOTO
 				{
 					(lex.p)++
 					goto _out
@@ -2842,7 +2846,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_ISSET
+				tok = T_IF
 				{
 					(lex.p)++
 					goto _out
@@ -2852,7 +2856,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_IMPLEMENTS
+				tok = T_ISSET
 				{
 					(lex.p)++
 					goto _out
@@ -2862,7 +2866,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_INSTANCEOF
+				tok = T_IMPLEMENTS
 				{
 					(lex.p)++
 					goto _out
@@ -2872,7 +2876,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_INSTEADOF
+				tok = T_INSTANCEOF
 				{
 					(lex.p)++
 					goto _out
@@ -2882,7 +2886,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_INTERFACE
+				tok = T_INSTEADOF
 				{
 					(lex.p)++
 					goto _out
@@ -2892,7 +2896,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_LIST
+				tok = T_INTERFACE
 				{
 					(lex.p)++
 					goto _out
@@ -2902,7 +2906,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_NAMESPACE
+				tok = T_LIST
 				{
 					(lex.p)++
 					goto _out
@@ -2912,7 +2916,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_PRIVATE
+				tok = T_NAMESPACE
 				{
 					(lex.p)++
 					goto _out
@@ -2922,7 +2926,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_PUBLIC
+				tok = T_PRIVATE
 				{
 					(lex.p)++
 					goto _out
@@ -2932,7 +2936,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_PRINT
+				tok = T_PUBLIC
 				{
 					(lex.p)++
 					goto _out
@@ -2942,7 +2946,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_PROTECTED
+				tok = T_PRINT
 				{
 					(lex.p)++
 					goto _out
@@ -2952,7 +2956,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_RETURN
+				tok = T_PROTECTED
 				{
 					(lex.p)++
 					goto _out
@@ -2962,7 +2966,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_STATIC
+				tok = T_RETURN
 				{
 					(lex.p)++
 					goto _out
@@ -2972,7 +2976,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_SWITCH
+				tok = T_STATIC
 				{
 					(lex.p)++
 					goto _out
@@ -2982,7 +2986,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_THROW
+				tok = T_SWITCH
 				{
 					(lex.p)++
 					goto _out
@@ -2992,7 +2996,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_TRAIT
+				tok = T_THROW
 				{
 					(lex.p)++
 					goto _out
@@ -3002,7 +3006,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_TRY
+				tok = T_TRAIT
 				{
 					(lex.p)++
 					goto _out
@@ -3012,7 +3016,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_UNSET
+				tok = T_TRY
 				{
 					(lex.p)++
 					goto _out
@@ -3022,7 +3026,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_USE
+				tok = T_UNSET
 				{
 					(lex.p)++
 					goto _out
@@ -3032,7 +3036,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_VAR
+				tok = T_USE
 				{
 					(lex.p)++
 					goto _out
@@ -3042,13 +3046,23 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_WHILE
+				tok = T_VAR
 				{
 					(lex.p)++
 					goto _out
 				}
 			}
 		case 68:
+			{
+				(lex.p) = (lex.te) - 1
+				lex.setTokenPosition(token)
+				tok = T_WHILE
+				{
+					(lex.p)++
+					goto _out
+				}
+			}
+		case 69:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3058,7 +3072,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 71:
+		case 72:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3068,7 +3082,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 73:
+		case 74:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3078,7 +3092,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 74:
+		case 75:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3088,7 +3102,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 75:
+		case 76:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3098,7 +3112,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 76:
+		case 77:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3108,7 +3122,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 77:
+		case 78:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3118,7 +3132,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 78:
+		case 79:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3128,7 +3142,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 79:
+		case 80:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3138,7 +3152,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 80:
+		case 81:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3148,7 +3162,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 81:
+		case 82:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3158,22 +3172,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 82:
-			{
-				(lex.p) = (lex.te) - 1
-				lex.setTokenPosition(token)
-				tok = T_HALT_COMPILER
-				lex.cs = 509
-				{
-					(lex.p)++
-					goto _out
-				}
-			}
 		case 83:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_NEW
+				tok = T_HALT_COMPILER
+				lex.cs = 510
 				{
 					(lex.p)++
 					goto _out
@@ -3183,7 +3187,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_LOGICAL_AND
+				tok = T_NEW
 				{
 					(lex.p)++
 					goto _out
@@ -3193,13 +3197,23 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
-				tok = T_LOGICAL_OR
+				tok = T_LOGICAL_AND
 				{
 					(lex.p)++
 					goto _out
 				}
 			}
 		case 86:
+			{
+				(lex.p) = (lex.te) - 1
+				lex.setTokenPosition(token)
+				tok = T_LOGICAL_OR
+				{
+					(lex.p)++
+					goto _out
+				}
+			}
+		case 87:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3209,7 +3223,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 115:
+		case 116:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3219,7 +3233,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 131:
+		case 133:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -3229,12 +3243,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 136:
+		case 138:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
 				tok = TokenID(int('"'))
-				lex.cs = 484
+				lex.cs = 485
 				{
 					(lex.p)++
 					goto _out
@@ -3244,7 +3258,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 
 		goto _again
 	tr11:
-//line scanner/scanner.rl:348
+//line scanner/scanner.rl:350
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3257,7 +3271,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr15:
-//line scanner/scanner.rl:371
+//line scanner/scanner.rl:373
 		(lex.p) = (lex.te) - 1
 		{
 			c := lex.data[lex.p]
@@ -3265,7 +3279,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr19:
-//line scanner/scanner.rl:333
+//line scanner/scanner.rl:335
 		(lex.p) = (lex.te) - 1
 		{
 			// rune, _ := utf8.DecodeRune(lex.data[lex.ts:lex.te]);
@@ -3280,7 +3294,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr34:
-//line scanner/scanner.rl:309
+//line scanner/scanner.rl:311
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3293,7 +3307,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr41:
-//line scanner/scanner.rl:314
+//line scanner/scanner.rl:316
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3306,7 +3320,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr45:
-//line scanner/scanner.rl:310
+//line scanner/scanner.rl:312
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3319,7 +3333,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr53:
-//line scanner/scanner.rl:311
+//line scanner/scanner.rl:313
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3332,7 +3346,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr60:
-//line scanner/scanner.rl:312
+//line scanner/scanner.rl:314
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3345,7 +3359,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr69:
-//line scanner/scanner.rl:313
+//line scanner/scanner.rl:315
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3358,7 +3372,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr80:
-//line scanner/scanner.rl:315
+//line scanner/scanner.rl:317
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3371,7 +3385,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr81:
-//line scanner/scanner.rl:278
+//line scanner/scanner.rl:279
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3397,7 +3411,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr92:
-//line scanner/scanner.rl:321
+//line scanner/scanner.rl:323
 		lex.te = (lex.p) + 1
 		{
 			isDocComment := false
@@ -3471,7 +3485,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto _again
 	tr124:
-//line scanner/scanner.rl:344
+//line scanner/scanner.rl:346
 		(lex.p) = (lex.te) - 1
 		{
 			lex.setTokenPosition(token)
@@ -3484,7 +3498,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr126:
-//line scanner/scanner.rl:259
+//line scanner/scanner.rl:260
 		(lex.p) = (lex.te) - 1
 		{
 			lex.setTokenPosition(token)
@@ -3497,7 +3511,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr137:
-//line scanner/scanner.rl:258
+//line scanner/scanner.rl:259
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3510,7 +3524,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr173:
-//line scanner/scanner.rl:371
+//line scanner/scanner.rl:373
 		lex.te = (lex.p) + 1
 		{
 			c := lex.data[lex.p]
@@ -3518,7 +3532,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr184:
-//line scanner/scanner.rl:333
+//line scanner/scanner.rl:335
 		lex.te = (lex.p) + 1
 		{
 			// rune, _ := utf8.DecodeRune(lex.data[lex.ts:lex.te]);
@@ -3533,7 +3547,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr218:
-//line scanner/scanner.rl:277
+//line scanner/scanner.rl:278
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3547,12 +3561,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 		goto st117
 	tr221:
 		lex.cs = 117
-//line scanner/scanner.rl:368
+//line scanner/scanner.rl:370
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
 			tok = TokenID(int('`'))
-			lex.cs = 478
+			lex.cs = 479
 			{
 				(lex.p)++
 				goto _out
@@ -3560,7 +3574,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto _again
 	tr222:
-//line scanner/scanner.rl:341
+//line scanner/scanner.rl:343
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3570,7 +3584,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr224:
-//line scanner/scanner.rl:342
+//line scanner/scanner.rl:344
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3599,7 +3613,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr231:
-//line scanner/scanner.rl:371
+//line scanner/scanner.rl:373
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -3608,7 +3622,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr232:
-//line scanner/scanner.rl:333
+//line scanner/scanner.rl:335
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -3624,7 +3638,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr234:
-//line scanner/scanner.rl:296
+//line scanner/scanner.rl:297
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -3638,7 +3652,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr235:
-//line scanner/scanner.rl:297
+//line scanner/scanner.rl:298
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3652,13 +3666,13 @@ func (lex *Lexer) Lex(lval Lval) int {
 		goto st117
 	tr236:
 		lex.cs = 117
-//line scanner/scanner.rl:369
+//line scanner/scanner.rl:371
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			lex.setTokenPosition(token)
 			tok = TokenID(int('"'))
-			lex.cs = 484
+			lex.cs = 485
 			{
 				(lex.p)++
 				goto _out
@@ -3666,7 +3680,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto _again
 	tr237:
-//line scanner/scanner.rl:317
+//line scanner/scanner.rl:319
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -3677,7 +3691,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 	tr239:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:317
+//line scanner/scanner.rl:319
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -3686,7 +3700,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr243:
-//line scanner/scanner.rl:343
+//line scanner/scanner.rl:345
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -3700,7 +3714,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr244:
-//line scanner/scanner.rl:291
+//line scanner/scanner.rl:292
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3713,7 +3727,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr245:
-//line scanner/scanner.rl:280
+//line scanner/scanner.rl:281
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3726,7 +3740,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr246:
-//line scanner/scanner.rl:282
+//line scanner/scanner.rl:283
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3739,7 +3753,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr248:
-//line scanner/scanner.rl:285
+//line scanner/scanner.rl:286
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3752,7 +3766,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr249:
-//line scanner/scanner.rl:304
+//line scanner/scanner.rl:305
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -3766,7 +3780,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr250:
-//line scanner/scanner.rl:286
+//line scanner/scanner.rl:287
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3779,7 +3793,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr251:
-//line scanner/scanner.rl:293
+//line scanner/scanner.rl:294
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3792,7 +3806,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr252:
-//line scanner/scanner.rl:288
+//line scanner/scanner.rl:289
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3805,7 +3819,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr253:
-//line scanner/scanner.rl:292
+//line scanner/scanner.rl:293
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3818,7 +3832,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr254:
-//line scanner/scanner.rl:289
+//line scanner/scanner.rl:290
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3832,12 +3846,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 		goto st117
 	tr255:
 		lex.cs = 117
-//line scanner/scanner.rl:346
+//line scanner/scanner.rl:348
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
 			tok = T_OBJECT_OPERATOR
-			lex.cs = 463
+			lex.cs = 464
 			{
 				(lex.p)++
 				goto _out
@@ -3845,7 +3859,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto _again
 	tr257:
-//line scanner/scanner.rl:284
+//line scanner/scanner.rl:285
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3872,7 +3886,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr261:
-//line scanner/scanner.rl:287
+//line scanner/scanner.rl:288
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -3971,7 +3985,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr269:
-//line scanner/scanner.rl:279
+//line scanner/scanner.rl:280
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -4016,7 +4030,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto _again
 	tr275:
-//line scanner/scanner.rl:296
+//line scanner/scanner.rl:297
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -4029,7 +4043,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr276:
-//line scanner/scanner.rl:305
+//line scanner/scanner.rl:306
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -4043,7 +4057,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr277:
-//line scanner/scanner.rl:300
+//line scanner/scanner.rl:301
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -4059,7 +4073,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		lex.cs = 117
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:354
+//line scanner/scanner.rl:356
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -4068,11 +4082,11 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_START_HEREDOC
 
 			if lex.isHeredocEnd(lex.p + 1) {
-				lex.cs = 490
+				lex.cs = 491
 			} else if lex.data[lblStart-1] == '\'' {
-				lex.cs = 469
+				lex.cs = 470
 			} else {
-				lex.cs = 472
+				lex.cs = 473
 			}
 			{
 				(lex.p)++
@@ -4081,7 +4095,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto _again
 	tr279:
-//line scanner/scanner.rl:303
+//line scanner/scanner.rl:304
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -4095,7 +4109,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr280:
-//line scanner/scanner.rl:295
+//line scanner/scanner.rl:296
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -4108,7 +4122,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr282:
-//line scanner/scanner.rl:294
+//line scanner/scanner.rl:295
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -4121,7 +4135,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr283:
-//line scanner/scanner.rl:298
+//line scanner/scanner.rl:299
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -4135,7 +4149,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr284:
-//line scanner/scanner.rl:299
+//line scanner/scanner.rl:300
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -4148,7 +4162,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr285:
-//line scanner/scanner.rl:302
+//line scanner/scanner.rl:303
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -4161,7 +4175,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr287:
-//line scanner/scanner.rl:306
+//line scanner/scanner.rl:307
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -4175,7 +4189,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st117
 	tr288:
-//line scanner/scanner.rl:301
+//line scanner/scanner.rl:302
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -4187,19 +4201,6 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto st117
-	tr290:
-//line scanner/scanner.rl:307
-		lex.te = (lex.p) + 1
-		{
-			lex.setTokenPosition(token)
-			tok = T_COALESCE
-			{
-				(lex.p)++
-				lex.cs = 117
-				goto _out
-			}
-		}
-		goto st117
 	tr291:
 		lex.cs = 117
 //line scanner/scanner.rl:162
@@ -4233,7 +4234,34 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto _again
 	tr294:
-//line scanner/scanner.rl:344
+//line scanner/scanner.rl:308
+		lex.te = (lex.p)
+		(lex.p)--
+		{
+			lex.setTokenPosition(token)
+			tok = T_COALESCE
+			{
+				(lex.p)++
+				lex.cs = 117
+				goto _out
+			}
+		}
+		goto st117
+	tr295:
+//line scanner/scanner.rl:309
+		lex.te = (lex.p) + 1
+		{
+			lex.setTokenPosition(token)
+			tok = T_COALESCE_EQUAL
+			{
+				(lex.p)++
+				lex.cs = 117
+				goto _out
+			}
+		}
+		goto st117
+	tr296:
+//line scanner/scanner.rl:346
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -4246,7 +4274,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto st117
-	tr374:
+	tr376:
 //line scanner/scanner.rl:217
 		lex.te = (lex.p)
 		(lex.p)--
@@ -4260,7 +4288,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto st117
-	tr394:
+	tr396:
 //line scanner/scanner.rl:221
 		lex.te = (lex.p)
 		(lex.p)--
@@ -4274,7 +4302,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto st117
-	tr422:
+	tr425:
 //line scanner/scanner.rl:229
 		lex.te = (lex.p)
 		(lex.p)--
@@ -4288,7 +4316,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto st117
-	tr426:
+	tr429:
 //line scanner/scanner.rl:231
 		lex.te = (lex.p)
 		(lex.p)--
@@ -4302,8 +4330,8 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto st117
-	tr458:
-//line scanner/scanner.rl:260
+	tr461:
+//line scanner/scanner.rl:261
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -4316,8 +4344,8 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto st117
-	tr526:
-//line scanner/scanner.rl:262
+	tr529:
+//line scanner/scanner.rl:263
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -4330,8 +4358,8 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto st117
-	tr572:
-//line scanner/scanner.rl:259
+	tr575:
+//line scanner/scanner.rl:260
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -4344,8 +4372,8 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto st117
-	tr577:
-//line scanner/scanner.rl:290
+	tr580:
+//line scanner/scanner.rl:291
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -4357,8 +4385,8 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto st117
-	tr651:
-//line scanner/scanner.rl:283
+	tr654:
+//line scanner/scanner.rl:284
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -4370,8 +4398,8 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto st117
-	tr652:
-//line scanner/scanner.rl:281
+	tr655:
+//line scanner/scanner.rl:282
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -4394,7 +4422,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 //line NONE:1
 		lex.ts = (lex.p)
 
-//line scanner/scanner.go:3273
+//line scanner/scanner.go:3286
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr7
@@ -4445,97 +4473,97 @@ func (lex *Lexer) Lex(lval Lval) int {
 		case 64:
 			goto tr184
 		case 65:
-			goto st160
+			goto st161
 		case 66:
 			goto tr198
 		case 67:
-			goto st176
+			goto st177
 		case 68:
-			goto st205
+			goto st206
 		case 69:
-			goto st216
+			goto st217
 		case 70:
-			goto st258
+			goto st259
 		case 71:
-			goto st269
+			goto st270
 		case 73:
-			goto st276
+			goto st277
 		case 76:
-			goto st315
+			goto st316
 		case 78:
-			goto st318
+			goto st319
 		case 79:
-			goto st327
-		case 80:
 			goto st328
+		case 80:
+			goto st329
 		case 82:
-			goto st345
+			goto st346
 		case 83:
-			goto st359
+			goto st360
 		case 84:
-			goto st368
+			goto st369
 		case 85:
-			goto st375
+			goto st376
 		case 86:
-			goto st380
+			goto st381
 		case 87:
-			goto st382
+			goto st383
 		case 88:
-			goto st386
+			goto st387
 		case 89:
-			goto st388
+			goto st389
 		case 92:
 			goto tr218
 		case 94:
-			goto st396
-		case 95:
 			goto st397
+		case 95:
+			goto st398
 		case 96:
 			goto tr221
 		case 97:
-			goto st160
+			goto st161
 		case 98:
 			goto tr198
 		case 99:
-			goto st176
+			goto st177
 		case 100:
-			goto st205
+			goto st206
 		case 101:
-			goto st216
+			goto st217
 		case 102:
-			goto st258
+			goto st259
 		case 103:
-			goto st269
+			goto st270
 		case 105:
-			goto st276
+			goto st277
 		case 108:
-			goto st315
+			goto st316
 		case 110:
-			goto st318
+			goto st319
 		case 111:
-			goto st327
-		case 112:
 			goto st328
+		case 112:
+			goto st329
 		case 114:
-			goto st345
+			goto st346
 		case 115:
-			goto st359
+			goto st360
 		case 116:
-			goto st368
+			goto st369
 		case 117:
-			goto st375
+			goto st376
 		case 118:
-			goto st380
+			goto st381
 		case 119:
-			goto st382
+			goto st383
 		case 120:
-			goto st386
+			goto st387
 		case 121:
-			goto st388
+			goto st389
 		case 123:
 			goto tr222
 		case 124:
-			goto st462
+			goto st463
 		case 125:
 			goto tr224
 		case 126:
@@ -4587,7 +4615,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof118
 		}
 	st_case_118:
-//line scanner/scanner.go:3466
+//line scanner/scanner.go:3479
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr7
@@ -4617,7 +4645,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof119
 		}
 	st_case_119:
-//line scanner/scanner.go:3496
+//line scanner/scanner.go:3509
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr229
@@ -4639,7 +4667,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof5
 		}
 	st_case_5:
-//line scanner/scanner.go:3518
+//line scanner/scanner.go:3531
 		if lex.data[(lex.p)] == 10 {
 			goto tr7
 		}
@@ -4675,15 +4703,15 @@ func (lex *Lexer) Lex(lval Lval) int {
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:369
-		lex.act = 136
+//line scanner/scanner.rl:371
+		lex.act = 138
 		goto st123
 	st123:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof123
 		}
 	st_case_123:
-//line scanner/scanner.go:3562
+//line scanner/scanner.go:3575
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr10
@@ -4716,7 +4744,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof6
 		}
 	st_case_6:
-//line scanner/scanner.go:3595
+//line scanner/scanner.go:3608
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr10
@@ -4799,7 +4827,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof124
 		}
 	st_case_124:
-//line scanner/scanner.go:3678
+//line scanner/scanner.go:3691
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -4854,7 +4882,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof125
 		}
 	st_case_125:
-//line scanner/scanner.go:3733
+//line scanner/scanner.go:3746
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -4978,7 +5006,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof130
 		}
 	st_case_130:
-//line scanner/scanner.go:3857
+//line scanner/scanner.go:3870
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr17
@@ -5007,7 +5035,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof10
 		}
 	st_case_10:
-//line scanner/scanner.go:3886
+//line scanner/scanner.go:3899
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr17
@@ -5041,7 +5069,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof131
 		}
 	st_case_131:
-//line scanner/scanner.go:3920
+//line scanner/scanner.go:3933
 		switch lex.data[(lex.p)] {
 		case 9:
 			goto st12
@@ -5889,7 +5917,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof136
 		}
 	st_case_136:
-//line scanner/scanner.go:4768
+//line scanner/scanner.go:4781
 		switch lex.data[(lex.p)] {
 		case 46:
 			goto st66
@@ -5921,7 +5949,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof137
 		}
 	st_case_137:
-//line scanner/scanner.go:4800
+//line scanner/scanner.go:4813
 		switch lex.data[(lex.p)] {
 		case 69:
 			goto st67
@@ -5970,7 +5998,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof138
 		}
 	st_case_138:
-//line scanner/scanner.go:4849
+//line scanner/scanner.go:4862
 		if lex.data[(lex.p)] == 95 {
 			goto st68
 		}
@@ -5997,7 +6025,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof139
 		}
 	st_case_139:
-//line scanner/scanner.go:4876
+//line scanner/scanner.go:4889
 		switch lex.data[(lex.p)] {
 		case 42:
 			goto st70
@@ -6016,7 +6044,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof70
 		}
 	st_case_70:
-//line scanner/scanner.go:4895
+//line scanner/scanner.go:4908
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st71
@@ -6033,7 +6061,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof71
 		}
 	st_case_71:
-//line scanner/scanner.go:4912
+//line scanner/scanner.go:4925
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr90
@@ -6050,7 +6078,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof72
 		}
 	st_case_72:
-//line scanner/scanner.go:4929
+//line scanner/scanner.go:4942
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st71
@@ -6072,7 +6100,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof140
 		}
 	st_case_140:
-//line scanner/scanner.go:4951
+//line scanner/scanner.go:4964
 		switch lex.data[(lex.p)] {
 		case 46:
 			goto tr263
@@ -6103,7 +6131,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof141
 		}
 	st_case_141:
-//line scanner/scanner.go:4982
+//line scanner/scanner.go:4995
 		switch lex.data[(lex.p)] {
 		case 69:
 			goto st67
@@ -6126,7 +6154,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof142
 		}
 	st_case_142:
-//line scanner/scanner.go:5005
+//line scanner/scanner.go:5018
 		switch lex.data[(lex.p)] {
 		case 46:
 			goto tr263
@@ -6171,7 +6199,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof143
 		}
 	st_case_143:
-//line scanner/scanner.go:5050
+//line scanner/scanner.go:5063
 		if lex.data[(lex.p)] == 95 {
 			goto st74
 		}
@@ -6209,7 +6237,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof144
 		}
 	st_case_144:
-//line scanner/scanner.go:5088
+//line scanner/scanner.go:5101
 		if lex.data[(lex.p)] == 95 {
 			goto st75
 		}
@@ -6245,7 +6273,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof146
 		}
 	st_case_146:
-//line scanner/scanner.go:5124
+//line scanner/scanner.go:5137
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st77
@@ -6269,7 +6297,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof76
 		}
 	st_case_76:
-//line scanner/scanner.go:5148
+//line scanner/scanner.go:5161
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st77
@@ -6293,7 +6321,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof77
 		}
 	st_case_77:
-//line scanner/scanner.go:5172
+//line scanner/scanner.go:5185
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr102
@@ -6317,7 +6345,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof78
 		}
 	st_case_78:
-//line scanner/scanner.go:5196
+//line scanner/scanner.go:5209
 		if lex.data[(lex.p)] == 10 {
 			goto st77
 		}
@@ -6331,7 +6359,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof79
 		}
 	st_case_79:
-//line scanner/scanner.go:5210
+//line scanner/scanner.go:5223
 		if lex.data[(lex.p)] == 62 {
 			goto tr105
 		}
@@ -6346,7 +6374,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof147
 		}
 	st_case_147:
-//line scanner/scanner.go:5225
+//line scanner/scanner.go:5238
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st148
@@ -6387,15 +6415,15 @@ func (lex *Lexer) Lex(lval Lval) int {
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:305
-		lex.act = 115
+//line scanner/scanner.rl:306
+		lex.act = 116
 		goto st150
 	st150:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof150
 		}
 	st_case_150:
-//line scanner/scanner.go:5274
+//line scanner/scanner.go:5287
 		switch lex.data[(lex.p)] {
 		case 60:
 			goto st81
@@ -6463,7 +6491,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof83
 		}
 	st_case_83:
-//line scanner/scanner.go:5342
+//line scanner/scanner.go:5355
 		switch lex.data[(lex.p)] {
 		case 34:
 			goto tr113
@@ -6497,7 +6525,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof84
 		}
 	st_case_84:
-//line scanner/scanner.go:5376
+//line scanner/scanner.go:5389
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st151
@@ -6514,7 +6542,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof151
 		}
 	st_case_151:
-//line scanner/scanner.go:5393
+//line scanner/scanner.go:5406
 		goto tr278
 	tr120:
 //line scanner/scanner.rl:48
@@ -6525,7 +6553,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof85
 		}
 	st_case_85:
-//line scanner/scanner.go:5404
+//line scanner/scanner.go:5417
 		if lex.data[(lex.p)] == 10 {
 			goto st151
 		}
@@ -6560,7 +6588,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof87
 		}
 	st_case_87:
-//line scanner/scanner.go:5439
+//line scanner/scanner.go:5452
 		switch lex.data[(lex.p)] {
 		case 39:
 			goto tr113
@@ -6594,7 +6622,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof88
 		}
 	st_case_88:
-//line scanner/scanner.go:5473
+//line scanner/scanner.go:5486
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr119
@@ -6681,7 +6709,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		case 62:
 			goto tr289
 		case 63:
-			goto tr290
+			goto st160
 		}
 		goto tr232
 	tr289:
@@ -6694,7 +6722,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof158
 		}
 	st_case_158:
-//line scanner/scanner.go:5573
+//line scanner/scanner.go:5586
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st159
@@ -6722,533 +6750,549 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof160
 		}
 	st_case_160:
+		if lex.data[(lex.p)] == 61 {
+			goto tr295
+		}
+		goto tr294
+	st161:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof161
+		}
+	st_case_161:
 		switch lex.data[(lex.p)] {
 		case 66:
-			goto st162
+			goto st163
 		case 78:
-			goto st168
+			goto st169
 		case 82:
-			goto st169
+			goto st170
 		case 83:
-			goto tr298
+			goto tr300
 		case 96:
-			goto tr294
+			goto tr296
 		case 98:
-			goto st162
+			goto st163
 		case 110:
-			goto st168
-		case 114:
 			goto st169
+		case 114:
+			goto st170
 		case 115:
-			goto tr298
+			goto tr300
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	tr204:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:344
-		lex.act = 131
-		goto st161
-	tr298:
+//line scanner/scanner.rl:346
+		lex.act = 133
+		goto st162
+	tr300:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:204
 		lex.act = 14
-		goto st161
-	tr304:
+		goto st162
+	tr306:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:202
 		lex.act = 12
-		goto st161
-	tr305:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:274
-		lex.act = 84
-		goto st161
-	tr308:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:203
-		lex.act = 13
-		goto st161
-	tr313:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:205
-		lex.act = 15
-		goto st161
-	tr325:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:206
-		lex.act = 16
-		goto st161
-	tr326:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:207
-		lex.act = 17
-		goto st161
-	tr328:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:208
-		lex.act = 18
-		goto st161
-	tr335:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:233
-		lex.act = 43
-		goto st161
-	tr339:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:209
-		lex.act = 19
-		goto st161
-	tr341:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:210
-		lex.act = 20
-		goto st161
-	tr345:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:211
-		lex.act = 21
-		goto st161
-	tr349:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:212
-		lex.act = 22
-		goto st161
-	tr352:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:215
-		lex.act = 25
-		goto st161
-	tr358:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:213
-		lex.act = 23
-		goto st161
-	tr362:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:214
-		lex.act = 24
-		goto st161
-	tr363:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:227
-		lex.act = 37
-		goto st161
-	tr371:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:216
-		lex.act = 26
-		goto st161
-	tr376:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:218
-		lex.act = 28
-		goto st161
-	tr379:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:219
-		lex.act = 29
-		goto st161
-	tr391:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:220
-		lex.act = 30
-		goto st161
-	tr398:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:222
-		lex.act = 32
-		goto st161
-	tr399:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:223
-		lex.act = 33
-		goto st161
-	tr404:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:224
-		lex.act = 34
-		goto st161
-	tr408:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:225
-		lex.act = 35
-		goto st161
-	tr410:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:226
-		lex.act = 36
-		goto st161
-	tr416:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:228
-		lex.act = 38
-		goto st161
-	tr424:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:230
-		lex.act = 40
-		goto st161
-	tr430:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:232
-		lex.act = 42
-		goto st161
-	tr436:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:234
-		lex.act = 44
-		goto st161
-	tr438:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:235
-		lex.act = 45
-		goto st161
-	tr439:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:236
-		lex.act = 46
-		goto st161
-	tr450:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:238
-		lex.act = 48
-		goto st161
-	tr463:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:261
-		lex.act = 71
-		goto st161
-	tr471:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:239
-		lex.act = 49
-		goto st161
-	tr475:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:240
-		lex.act = 50
-		goto st161
-	tr481:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:241
-		lex.act = 51
-		goto st161
-	tr484:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:237
-		lex.act = 47
-		goto st161
-	tr487:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:242
-		lex.act = 52
-		goto st161
-	tr496:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:243
-		lex.act = 53
-		goto st161
-	tr497:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:273
-		lex.act = 83
-		goto st161
-	tr498:
+		goto st162
+	tr307:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:275
 		lex.act = 85
-		goto st161
-	tr505:
+		goto st162
+	tr310:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:246
-		lex.act = 56
-		goto st161
-	tr508:
+//line scanner/scanner.rl:203
+		lex.act = 13
+		goto st162
+	tr315:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:205
+		lex.act = 15
+		goto st162
+	tr327:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:206
+		lex.act = 16
+		goto st162
+	tr328:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:207
+		lex.act = 17
+		goto st162
+	tr330:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:208
+		lex.act = 18
+		goto st162
+	tr337:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:233
+		lex.act = 43
+		goto st162
+	tr341:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:209
+		lex.act = 19
+		goto st162
+	tr343:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:210
+		lex.act = 20
+		goto st162
+	tr347:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:211
+		lex.act = 21
+		goto st162
+	tr351:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:212
+		lex.act = 22
+		goto st162
+	tr354:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:215
+		lex.act = 25
+		goto st162
+	tr360:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:213
+		lex.act = 23
+		goto st162
+	tr364:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:214
+		lex.act = 24
+		goto st162
+	tr365:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:227
+		lex.act = 37
+		goto st162
+	tr373:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:216
+		lex.act = 26
+		goto st162
+	tr378:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:218
+		lex.act = 28
+		goto st162
+	tr381:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:219
+		lex.act = 29
+		goto st162
+	tr393:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:220
+		lex.act = 30
+		goto st162
+	tr400:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:222
+		lex.act = 32
+		goto st162
+	tr401:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:223
+		lex.act = 33
+		goto st162
+	tr406:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:224
+		lex.act = 34
+		goto st162
+	tr410:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:225
+		lex.act = 35
+		goto st162
+	tr412:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:226
+		lex.act = 36
+		goto st162
+	tr418:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:228
+		lex.act = 38
+		goto st162
+	tr420:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:234
+		lex.act = 44
+		goto st162
+	tr427:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:230
+		lex.act = 40
+		goto st162
+	tr433:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:232
+		lex.act = 42
+		goto st162
+	tr439:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:235
+		lex.act = 45
+		goto st162
+	tr441:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:236
+		lex.act = 46
+		goto st162
+	tr442:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:237
+		lex.act = 47
+		goto st162
+	tr453:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:239
+		lex.act = 49
+		goto st162
+	tr466:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:262
+		lex.act = 72
+		goto st162
+	tr474:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:240
+		lex.act = 50
+		goto st162
+	tr478:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:241
+		lex.act = 51
+		goto st162
+	tr484:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:242
+		lex.act = 52
+		goto st162
+	tr487:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:238
+		lex.act = 48
+		goto st162
+	tr490:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:243
+		lex.act = 53
+		goto st162
+	tr499:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:244
 		lex.act = 54
-		goto st161
-	tr514:
+		goto st162
+	tr500:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:247
-		lex.act = 57
-		goto st161
-	tr518:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:245
-		lex.act = 55
-		goto st161
-	tr531:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:263
-		lex.act = 73
-		goto st161
-	tr534:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:248
-		lex.act = 58
-		goto st161
-	tr540:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:249
-		lex.act = 59
-		goto st161
-	tr544:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:250
-		lex.act = 60
-		goto st161
-	tr549:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:251
-		lex.act = 61
-		goto st161
-	tr551:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:253
-		lex.act = 63
-		goto st161
-	tr553:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:252
-		lex.act = 62
-		goto st161
-	tr558:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:254
-		lex.act = 64
-		goto st161
-	tr559:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:255
-		lex.act = 65
-		goto st161
-	tr561:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:256
-		lex.act = 66
-		goto st161
-	tr565:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:257
-		lex.act = 67
-		goto st161
-	tr567:
+//line scanner/scanner.rl:274
+		lex.act = 84
+		goto st162
+	tr501:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:276
 		lex.act = 86
-		goto st161
-	tr576:
+		goto st162
+	tr508:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:258
-		lex.act = 68
-		goto st161
-	tr592:
+//line scanner/scanner.rl:247
+		lex.act = 57
+		goto st162
+	tr511:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:245
+		lex.act = 55
+		goto st162
+	tr517:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:248
+		lex.act = 58
+		goto st162
+	tr521:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:246
+		lex.act = 56
+		goto st162
+	tr534:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:264
 		lex.act = 74
-		goto st161
-	tr596:
+		goto st162
+	tr537:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:249
+		lex.act = 59
+		goto st162
+	tr543:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:250
+		lex.act = 60
+		goto st162
+	tr547:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:251
+		lex.act = 61
+		goto st162
+	tr552:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:252
+		lex.act = 62
+		goto st162
+	tr554:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:254
+		lex.act = 64
+		goto st162
+	tr556:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:253
+		lex.act = 63
+		goto st162
+	tr561:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:255
+		lex.act = 65
+		goto st162
+	tr562:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:256
+		lex.act = 66
+		goto st162
+	tr564:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:257
+		lex.act = 67
+		goto st162
+	tr568:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:258
+		lex.act = 68
+		goto st162
+	tr570:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:277
+		lex.act = 87
+		goto st162
+	tr579:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:259
+		lex.act = 69
+		goto st162
+	tr595:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:265
 		lex.act = 75
-		goto st161
-	tr602:
+		goto st162
+	tr599:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:266
 		lex.act = 76
-		goto st161
-	tr610:
+		goto st162
+	tr605:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:267
 		lex.act = 77
-		goto st161
-	tr622:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:272
-		lex.act = 82
-		goto st161
-	tr627:
+		goto st162
+	tr613:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:268
 		lex.act = 78
-		goto st161
-	tr634:
+		goto st162
+	tr625:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:270
-		lex.act = 80
-		goto st161
-	tr644:
+//line scanner/scanner.rl:273
+		lex.act = 83
+		goto st162
+	tr630:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:269
 		lex.act = 79
-		goto st161
-	tr650:
+		goto st162
+	tr637:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:271
 		lex.act = 81
-		goto st161
-	st161:
+		goto st162
+	tr647:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:270
+		lex.act = 80
+		goto st162
+	tr653:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:272
+		lex.act = 82
+		goto st162
+	st162:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof161
+			goto _test_eof162
 		}
-	st_case_161:
-//line scanner/scanner.go:6127
+	st_case_162:
+//line scanner/scanner.go:6156
 		if lex.data[(lex.p)] == 96 {
 			goto tr8
 		}
@@ -7270,66 +7314,35 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto tr8
 		}
 		goto tr204
-	st162:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof162
-		}
-	st_case_162:
-		switch lex.data[(lex.p)] {
-		case 83:
-			goto st163
-		case 96:
-			goto tr294
-		case 115:
-			goto st163
-		}
-		switch {
-		case lex.data[(lex.p)] < 58:
-			if lex.data[(lex.p)] <= 47 {
-				goto tr294
-			}
-		case lex.data[(lex.p)] > 64:
-			switch {
-			case lex.data[(lex.p)] > 94:
-				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
-				}
-			case lex.data[(lex.p)] >= 91:
-				goto tr294
-			}
-		default:
-			goto tr294
-		}
-		goto tr204
 	st163:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof163
 		}
 	st_case_163:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 83:
 			goto st164
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 115:
 			goto st164
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st164:
@@ -7338,29 +7351,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_164:
 		switch lex.data[(lex.p)] {
-		case 82:
+		case 84:
 			goto st165
 		case 96:
-			goto tr294
-		case 114:
+			goto tr296
+		case 116:
 			goto st165
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st165:
@@ -7369,29 +7382,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_165:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 82:
 			goto st166
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 114:
 			goto st166
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st166:
@@ -7400,29 +7413,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_166:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 65:
 			goto st167
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 97:
 			goto st167
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st167:
@@ -7431,29 +7444,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_167:
 		switch lex.data[(lex.p)] {
-		case 84:
-			goto tr304
+		case 67:
+			goto st168
 		case 96:
-			goto tr294
-		case 116:
-			goto tr304
+			goto tr296
+		case 99:
+			goto st168
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st168:
@@ -7462,29 +7475,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_168:
 		switch lex.data[(lex.p)] {
-		case 68:
-			goto tr305
+		case 84:
+			goto tr306
 		case 96:
-			goto tr294
-		case 100:
-			goto tr305
+			goto tr296
+		case 116:
+			goto tr306
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st169:
@@ -7493,29 +7506,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_169:
 		switch lex.data[(lex.p)] {
-		case 82:
-			goto st170
+		case 68:
+			goto tr307
 		case 96:
-			goto tr294
-		case 114:
-			goto st170
+			goto tr296
+		case 100:
+			goto tr307
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st170:
@@ -7524,29 +7537,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_170:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 82:
 			goto st171
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 114:
 			goto st171
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st171:
@@ -7555,72 +7568,103 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_171:
 		switch lex.data[(lex.p)] {
-		case 89:
-			goto tr308
+		case 65:
+			goto st172
 		case 96:
-			goto tr294
-		case 121:
-			goto tr308
+			goto tr296
+		case 97:
+			goto st172
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
+		}
+		goto tr204
+	st172:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof172
+		}
+	st_case_172:
+		switch lex.data[(lex.p)] {
+		case 89:
+			goto tr310
+		case 96:
+			goto tr296
+		case 121:
+			goto tr310
+		}
+		switch {
+		case lex.data[(lex.p)] < 58:
+			if lex.data[(lex.p)] <= 47 {
+				goto tr296
+			}
+		case lex.data[(lex.p)] > 64:
+			switch {
+			case lex.data[(lex.p)] > 94:
+				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
+					goto tr296
+				}
+			case lex.data[(lex.p)] >= 91:
+				goto tr296
+			}
+		default:
+			goto tr296
 		}
 		goto tr204
 	tr198:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:344
-		lex.act = 131
-		goto st172
-	st172:
+//line scanner/scanner.rl:346
+		lex.act = 133
+		goto st173
+	st173:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof172
+			goto _test_eof173
 		}
-	st_case_172:
-//line scanner/scanner.go:6471
+	st_case_173:
+//line scanner/scanner.go:6500
 		switch lex.data[(lex.p)] {
 		case 34:
 			goto st6
 		case 60:
 			goto st90
 		case 82:
-			goto st173
+			goto st174
 		case 96:
-			goto tr294
+			goto tr296
 		case 114:
-			goto st173
+			goto st174
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st90:
@@ -7641,66 +7685,35 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto st81
 		}
 		goto tr124
-	st173:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof173
-		}
-	st_case_173:
-		switch lex.data[(lex.p)] {
-		case 69:
-			goto st174
-		case 96:
-			goto tr294
-		case 101:
-			goto st174
-		}
-		switch {
-		case lex.data[(lex.p)] < 58:
-			if lex.data[(lex.p)] <= 47 {
-				goto tr294
-			}
-		case lex.data[(lex.p)] > 64:
-			switch {
-			case lex.data[(lex.p)] > 94:
-				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
-				}
-			case lex.data[(lex.p)] >= 91:
-				goto tr294
-			}
-		default:
-			goto tr294
-		}
-		goto tr204
 	st174:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof174
 		}
 	st_case_174:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 69:
 			goto st175
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 101:
 			goto st175
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st175:
@@ -7709,29 +7722,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_175:
 		switch lex.data[(lex.p)] {
-		case 75:
-			goto tr313
+		case 65:
+			goto st176
 		case 96:
-			goto tr294
-		case 107:
-			goto tr313
+			goto tr296
+		case 97:
+			goto st176
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st176:
@@ -7740,41 +7753,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_176:
 		switch lex.data[(lex.p)] {
-		case 65:
-			goto st177
-		case 70:
-			goto st186
-		case 76:
-			goto st193
-		case 79:
-			goto st198
+		case 75:
+			goto tr315
 		case 96:
-			goto tr294
-		case 97:
-			goto st177
-		case 102:
-			goto st186
-		case 108:
-			goto st193
-		case 111:
-			goto st198
+			goto tr296
+		case 107:
+			goto tr315
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st177:
@@ -7783,37 +7784,41 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_177:
 		switch lex.data[(lex.p)] {
+		case 65:
+			goto st178
+		case 70:
+			goto st187
 		case 76:
-			goto st178
-		case 83:
-			goto st183
-		case 84:
-			goto st184
+			goto st194
+		case 79:
+			goto st199
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 97:
 			goto st178
-		case 115:
-			goto st183
-		case 116:
-			goto st184
+		case 102:
+			goto st187
+		case 108:
+			goto st194
+		case 111:
+			goto st199
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st178:
@@ -7824,27 +7829,35 @@ func (lex *Lexer) Lex(lval Lval) int {
 		switch lex.data[(lex.p)] {
 		case 76:
 			goto st179
+		case 83:
+			goto st184
+		case 84:
+			goto st185
 		case 96:
-			goto tr294
+			goto tr296
 		case 108:
 			goto st179
+		case 115:
+			goto st184
+		case 116:
+			goto st185
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st179:
@@ -7853,29 +7866,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_179:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 76:
 			goto st180
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 108:
 			goto st180
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st180:
@@ -7884,29 +7897,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_180:
 		switch lex.data[(lex.p)] {
-		case 66:
+		case 65:
 			goto st181
 		case 96:
-			goto tr294
-		case 98:
+			goto tr296
+		case 97:
 			goto st181
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st181:
@@ -7915,29 +7928,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_181:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 66:
 			goto st182
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 98:
 			goto st182
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st182:
@@ -7946,29 +7959,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_182:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr325
+		case 76:
+			goto st183
 		case 96:
-			goto tr294
-		case 101:
-			goto tr325
+			goto tr296
+		case 108:
+			goto st183
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st183:
@@ -7978,28 +7991,28 @@ func (lex *Lexer) Lex(lval Lval) int {
 	st_case_183:
 		switch lex.data[(lex.p)] {
 		case 69:
-			goto tr326
+			goto tr327
 		case 96:
-			goto tr294
+			goto tr296
 		case 101:
-			goto tr326
+			goto tr327
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st184:
@@ -8008,29 +8021,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_184:
 		switch lex.data[(lex.p)] {
-		case 67:
-			goto st185
+		case 69:
+			goto tr328
 		case 96:
-			goto tr294
-		case 99:
-			goto st185
+			goto tr296
+		case 101:
+			goto tr328
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st185:
@@ -8039,29 +8052,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_185:
 		switch lex.data[(lex.p)] {
-		case 72:
-			goto tr328
+		case 67:
+			goto st186
 		case 96:
-			goto tr294
-		case 104:
-			goto tr328
+			goto tr296
+		case 99:
+			goto st186
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st186:
@@ -8070,29 +8083,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_186:
 		switch lex.data[(lex.p)] {
-		case 85:
-			goto st187
+		case 72:
+			goto tr330
 		case 96:
-			goto tr294
-		case 117:
-			goto st187
+			goto tr296
+		case 104:
+			goto tr330
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st187:
@@ -8101,29 +8114,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_187:
 		switch lex.data[(lex.p)] {
-		case 78:
+		case 85:
 			goto st188
 		case 96:
-			goto tr294
-		case 110:
+			goto tr296
+		case 117:
 			goto st188
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st188:
@@ -8132,29 +8145,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_188:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 78:
 			goto st189
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 110:
 			goto st189
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st189:
@@ -8163,29 +8176,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_189:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 67:
 			goto st190
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 99:
 			goto st190
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st190:
@@ -8194,29 +8207,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_190:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 84:
 			goto st191
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 116:
 			goto st191
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st191:
@@ -8225,29 +8238,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_191:
 		switch lex.data[(lex.p)] {
-		case 79:
+		case 73:
 			goto st192
 		case 96:
-			goto tr294
-		case 111:
+			goto tr296
+		case 105:
 			goto st192
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st192:
@@ -8256,29 +8269,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_192:
 		switch lex.data[(lex.p)] {
-		case 78:
-			goto tr335
+		case 79:
+			goto st193
 		case 96:
-			goto tr294
-		case 110:
-			goto tr335
+			goto tr296
+		case 111:
+			goto st193
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st193:
@@ -8287,33 +8300,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_193:
 		switch lex.data[(lex.p)] {
-		case 65:
-			goto st194
-		case 79:
-			goto st196
+		case 78:
+			goto tr337
 		case 96:
-			goto tr294
-		case 97:
-			goto st194
-		case 111:
-			goto st196
+			goto tr296
+		case 110:
+			goto tr337
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st194:
@@ -8322,29 +8331,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_194:
 		switch lex.data[(lex.p)] {
-		case 83:
+		case 65:
 			goto st195
+		case 79:
+			goto st197
 		case 96:
-			goto tr294
-		case 115:
+			goto tr296
+		case 97:
 			goto st195
+		case 111:
+			goto st197
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st195:
@@ -8354,28 +8367,28 @@ func (lex *Lexer) Lex(lval Lval) int {
 	st_case_195:
 		switch lex.data[(lex.p)] {
 		case 83:
-			goto tr339
+			goto st196
 		case 96:
-			goto tr294
+			goto tr296
 		case 115:
-			goto tr339
+			goto st196
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st196:
@@ -8384,29 +8397,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_196:
 		switch lex.data[(lex.p)] {
-		case 78:
-			goto st197
+		case 83:
+			goto tr341
 		case 96:
-			goto tr294
-		case 110:
-			goto st197
+			goto tr296
+		case 115:
+			goto tr341
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st197:
@@ -8415,29 +8428,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_197:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr341
+		case 78:
+			goto st198
 		case 96:
-			goto tr294
-		case 101:
-			goto tr341
+			goto tr296
+		case 110:
+			goto st198
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st198:
@@ -8446,29 +8459,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_198:
 		switch lex.data[(lex.p)] {
-		case 78:
-			goto st199
+		case 69:
+			goto tr343
 		case 96:
-			goto tr294
-		case 110:
-			goto st199
+			goto tr296
+		case 101:
+			goto tr343
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st199:
@@ -8477,33 +8490,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_199:
 		switch lex.data[(lex.p)] {
-		case 83:
+		case 78:
 			goto st200
-		case 84:
-			goto st201
 		case 96:
-			goto tr294
-		case 115:
+			goto tr296
+		case 110:
 			goto st200
-		case 116:
-			goto st201
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st200:
@@ -8512,29 +8521,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_200:
 		switch lex.data[(lex.p)] {
+		case 83:
+			goto st201
 		case 84:
-			goto tr345
+			goto st202
 		case 96:
-			goto tr294
+			goto tr296
+		case 115:
+			goto st201
 		case 116:
-			goto tr345
+			goto st202
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st201:
@@ -8543,29 +8556,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_201:
 		switch lex.data[(lex.p)] {
-		case 73:
-			goto st202
+		case 84:
+			goto tr347
 		case 96:
-			goto tr294
-		case 105:
-			goto st202
+			goto tr296
+		case 116:
+			goto tr347
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st202:
@@ -8574,29 +8587,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_202:
 		switch lex.data[(lex.p)] {
-		case 78:
+		case 73:
 			goto st203
 		case 96:
-			goto tr294
-		case 110:
+			goto tr296
+		case 105:
 			goto st203
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st203:
@@ -8605,29 +8618,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_203:
 		switch lex.data[(lex.p)] {
-		case 85:
+		case 78:
 			goto st204
 		case 96:
-			goto tr294
-		case 117:
+			goto tr296
+		case 110:
 			goto st204
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st204:
@@ -8636,29 +8649,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_204:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr349
+		case 85:
+			goto st205
 		case 96:
-			goto tr294
-		case 101:
-			goto tr349
+			goto tr296
+		case 117:
+			goto st205
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st205:
@@ -8668,36 +8681,28 @@ func (lex *Lexer) Lex(lval Lval) int {
 	st_case_205:
 		switch lex.data[(lex.p)] {
 		case 69:
-			goto st206
-		case 73:
-			goto st215
-		case 79:
-			goto tr352
+			goto tr351
 		case 96:
-			goto tr294
+			goto tr296
 		case 101:
-			goto st206
-		case 105:
-			goto st215
-		case 111:
-			goto tr352
+			goto tr351
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st206:
@@ -8706,33 +8711,37 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_206:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 69:
 			goto st207
-		case 70:
-			goto st211
+		case 73:
+			goto st216
+		case 79:
+			goto tr354
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 101:
 			goto st207
-		case 102:
-			goto st211
+		case 105:
+			goto st216
+		case 111:
+			goto tr354
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st207:
@@ -8741,29 +8750,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_207:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 67:
 			goto st208
+		case 70:
+			goto st212
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 99:
 			goto st208
+		case 102:
+			goto st212
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st208:
@@ -8772,29 +8785,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_208:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 76:
 			goto st209
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 108:
 			goto st209
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st209:
@@ -8803,29 +8816,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_209:
 		switch lex.data[(lex.p)] {
-		case 82:
+		case 65:
 			goto st210
 		case 96:
-			goto tr294
-		case 114:
+			goto tr296
+		case 97:
 			goto st210
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st210:
@@ -8834,29 +8847,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_210:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr358
+		case 82:
+			goto st211
 		case 96:
-			goto tr294
-		case 101:
-			goto tr358
+			goto tr296
+		case 114:
+			goto st211
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st211:
@@ -8865,29 +8878,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_211:
 		switch lex.data[(lex.p)] {
-		case 65:
-			goto st212
+		case 69:
+			goto tr360
 		case 96:
-			goto tr294
-		case 97:
-			goto st212
+			goto tr296
+		case 101:
+			goto tr360
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st212:
@@ -8896,29 +8909,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_212:
 		switch lex.data[(lex.p)] {
-		case 85:
+		case 65:
 			goto st213
 		case 96:
-			goto tr294
-		case 117:
+			goto tr296
+		case 97:
 			goto st213
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st213:
@@ -8927,29 +8940,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_213:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 85:
 			goto st214
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 117:
 			goto st214
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st214:
@@ -8958,29 +8971,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_214:
 		switch lex.data[(lex.p)] {
-		case 84:
-			goto tr362
+		case 76:
+			goto st215
 		case 96:
-			goto tr294
-		case 116:
-			goto tr362
+			goto tr296
+		case 108:
+			goto st215
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st215:
@@ -8989,29 +9002,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_215:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr363
+		case 84:
+			goto tr364
 		case 96:
-			goto tr294
-		case 101:
-			goto tr363
+			goto tr296
+		case 116:
+			goto tr364
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st216:
@@ -9020,49 +9033,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_216:
 		switch lex.data[(lex.p)] {
-		case 67:
-			goto st217
-		case 76:
-			goto st219
-		case 77:
-			goto st223
-		case 78:
-			goto st226
-		case 86:
-			goto st250
-		case 88:
-			goto st252
+		case 69:
+			goto tr365
 		case 96:
-			goto tr294
-		case 99:
-			goto st217
-		case 108:
-			goto st219
-		case 109:
-			goto st223
-		case 110:
-			goto st226
-		case 118:
-			goto st250
-		case 120:
-			goto st252
+			goto tr296
+		case 101:
+			goto tr365
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st217:
@@ -9071,29 +9064,49 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_217:
 		switch lex.data[(lex.p)] {
-		case 72:
+		case 67:
 			goto st218
+		case 76:
+			goto st220
+		case 77:
+			goto st224
+		case 78:
+			goto st227
+		case 86:
+			goto st251
+		case 88:
+			goto st253
 		case 96:
-			goto tr294
-		case 104:
+			goto tr296
+		case 99:
 			goto st218
+		case 108:
+			goto st220
+		case 109:
+			goto st224
+		case 110:
+			goto st227
+		case 118:
+			goto st251
+		case 120:
+			goto st253
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st218:
@@ -9102,29 +9115,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_218:
 		switch lex.data[(lex.p)] {
-		case 79:
-			goto tr371
+		case 72:
+			goto st219
 		case 96:
-			goto tr294
-		case 111:
-			goto tr371
+			goto tr296
+		case 104:
+			goto st219
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st219:
@@ -9133,29 +9146,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_219:
 		switch lex.data[(lex.p)] {
-		case 83:
-			goto st220
+		case 79:
+			goto tr373
 		case 96:
-			goto tr294
-		case 115:
-			goto st220
+			goto tr296
+		case 111:
+			goto tr373
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st220:
@@ -9164,29 +9177,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_220:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 83:
 			goto st221
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 115:
 			goto st221
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st221:
@@ -9195,29 +9208,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_221:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 69:
 			goto st222
 		case 96:
-			goto tr374
-		case 105:
+			goto tr296
+		case 101:
 			goto st222
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr374
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr374
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr374
+				goto tr296
 			}
 		default:
-			goto tr374
+			goto tr296
 		}
 		goto tr204
 	st222:
@@ -9226,29 +9239,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_222:
 		switch lex.data[(lex.p)] {
-		case 70:
-			goto tr376
+		case 73:
+			goto st223
 		case 96:
-			goto tr294
-		case 102:
 			goto tr376
+		case 105:
+			goto st223
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr376
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr376
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr376
 			}
 		default:
-			goto tr294
+			goto tr376
 		}
 		goto tr204
 	st223:
@@ -9257,29 +9270,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_223:
 		switch lex.data[(lex.p)] {
-		case 80:
-			goto st224
+		case 70:
+			goto tr378
 		case 96:
-			goto tr294
-		case 112:
-			goto st224
+			goto tr296
+		case 102:
+			goto tr378
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st224:
@@ -9288,29 +9301,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_224:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 80:
 			goto st225
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 112:
 			goto st225
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st225:
@@ -9319,29 +9332,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_225:
 		switch lex.data[(lex.p)] {
-		case 89:
-			goto tr379
+		case 84:
+			goto st226
 		case 96:
-			goto tr294
-		case 121:
-			goto tr379
+			goto tr296
+		case 116:
+			goto st226
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st226:
@@ -9350,29 +9363,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_226:
 		switch lex.data[(lex.p)] {
-		case 68:
-			goto st227
+		case 89:
+			goto tr381
 		case 96:
-			goto tr294
-		case 100:
-			goto st227
+			goto tr296
+		case 121:
+			goto tr381
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st227:
@@ -9383,43 +9396,27 @@ func (lex *Lexer) Lex(lval Lval) int {
 		switch lex.data[(lex.p)] {
 		case 68:
 			goto st228
-		case 70:
-			goto st234
-		case 73:
-			goto st240
-		case 83:
-			goto st241
-		case 87:
-			goto st246
 		case 96:
-			goto tr294
+			goto tr296
 		case 100:
 			goto st228
-		case 102:
-			goto st234
-		case 105:
-			goto st240
-		case 115:
-			goto st241
-		case 119:
-			goto st246
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st228:
@@ -9428,29 +9425,45 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_228:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 68:
 			goto st229
+		case 70:
+			goto st235
+		case 73:
+			goto st241
+		case 83:
+			goto st242
+		case 87:
+			goto st247
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 100:
 			goto st229
+		case 102:
+			goto st235
+		case 105:
+			goto st241
+		case 115:
+			goto st242
+		case 119:
+			goto st247
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st229:
@@ -9459,29 +9472,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_229:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 69:
 			goto st230
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 101:
 			goto st230
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st230:
@@ -9490,29 +9503,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_230:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 67:
 			goto st231
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 99:
 			goto st231
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st231:
@@ -9521,29 +9534,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_231:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 76:
 			goto st232
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 108:
 			goto st232
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st232:
@@ -9552,29 +9565,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_232:
 		switch lex.data[(lex.p)] {
-		case 82:
+		case 65:
 			goto st233
 		case 96:
-			goto tr294
-		case 114:
+			goto tr296
+		case 97:
 			goto st233
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st233:
@@ -9583,29 +9596,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_233:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr391
+		case 82:
+			goto st234
 		case 96:
-			goto tr294
-		case 101:
-			goto tr391
+			goto tr296
+		case 114:
+			goto st234
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st234:
@@ -9614,29 +9627,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_234:
 		switch lex.data[(lex.p)] {
-		case 79:
-			goto st235
+		case 69:
+			goto tr393
 		case 96:
-			goto tr294
-		case 111:
-			goto st235
+			goto tr296
+		case 101:
+			goto tr393
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st235:
@@ -9645,29 +9658,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_235:
 		switch lex.data[(lex.p)] {
-		case 82:
+		case 79:
 			goto st236
 		case 96:
-			goto tr294
-		case 114:
+			goto tr296
+		case 111:
 			goto st236
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st236:
@@ -9676,29 +9689,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_236:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 82:
 			goto st237
 		case 96:
-			goto tr394
-		case 101:
+			goto tr296
+		case 114:
 			goto st237
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr394
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr394
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr394
+				goto tr296
 			}
 		default:
-			goto tr394
+			goto tr296
 		}
 		goto tr204
 	st237:
@@ -9707,29 +9720,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_237:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 69:
 			goto st238
 		case 96:
-			goto tr294
-		case 97:
+			goto tr396
+		case 101:
 			goto st238
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr396
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr396
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr396
 			}
 		default:
-			goto tr294
+			goto tr396
 		}
 		goto tr204
 	st238:
@@ -9738,29 +9751,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_238:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 65:
 			goto st239
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 97:
 			goto st239
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st239:
@@ -9769,29 +9782,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_239:
 		switch lex.data[(lex.p)] {
-		case 72:
-			goto tr398
+		case 67:
+			goto st240
 		case 96:
-			goto tr294
-		case 104:
-			goto tr398
+			goto tr296
+		case 99:
+			goto st240
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st240:
@@ -9800,29 +9813,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_240:
 		switch lex.data[(lex.p)] {
-		case 70:
-			goto tr399
+		case 72:
+			goto tr400
 		case 96:
-			goto tr294
-		case 102:
-			goto tr399
+			goto tr296
+		case 104:
+			goto tr400
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st241:
@@ -9831,29 +9844,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_241:
 		switch lex.data[(lex.p)] {
-		case 87:
-			goto st242
+		case 70:
+			goto tr401
 		case 96:
-			goto tr294
-		case 119:
-			goto st242
+			goto tr296
+		case 102:
+			goto tr401
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st242:
@@ -9862,29 +9875,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_242:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 87:
 			goto st243
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 119:
 			goto st243
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st243:
@@ -9893,29 +9906,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_243:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 73:
 			goto st244
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 105:
 			goto st244
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st244:
@@ -9924,29 +9937,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_244:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 84:
 			goto st245
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 116:
 			goto st245
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st245:
@@ -9955,29 +9968,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_245:
 		switch lex.data[(lex.p)] {
-		case 72:
-			goto tr404
+		case 67:
+			goto st246
 		case 96:
-			goto tr294
-		case 104:
-			goto tr404
+			goto tr296
+		case 99:
+			goto st246
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st246:
@@ -9987,28 +10000,28 @@ func (lex *Lexer) Lex(lval Lval) int {
 	st_case_246:
 		switch lex.data[(lex.p)] {
 		case 72:
-			goto st247
+			goto tr406
 		case 96:
-			goto tr294
+			goto tr296
 		case 104:
-			goto st247
+			goto tr406
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st247:
@@ -10017,29 +10030,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_247:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 72:
 			goto st248
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 104:
 			goto st248
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st248:
@@ -10048,29 +10061,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_248:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 73:
 			goto st249
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 105:
 			goto st249
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st249:
@@ -10079,29 +10092,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_249:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr408
+		case 76:
+			goto st250
 		case 96:
-			goto tr294
-		case 101:
-			goto tr408
+			goto tr296
+		case 108:
+			goto st250
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st250:
@@ -10110,29 +10123,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_250:
 		switch lex.data[(lex.p)] {
-		case 65:
-			goto st251
+		case 69:
+			goto tr410
 		case 96:
-			goto tr294
-		case 97:
-			goto st251
+			goto tr296
+		case 101:
+			goto tr410
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st251:
@@ -10141,29 +10154,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_251:
 		switch lex.data[(lex.p)] {
-		case 76:
-			goto tr410
+		case 65:
+			goto st252
 		case 96:
-			goto tr294
-		case 108:
-			goto tr410
+			goto tr296
+		case 97:
+			goto st252
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st252:
@@ -10172,33 +10185,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_252:
 		switch lex.data[(lex.p)] {
-		case 73:
-			goto st253
-		case 84:
-			goto st254
+		case 76:
+			goto tr412
 		case 96:
-			goto tr294
-		case 105:
-			goto st253
-		case 116:
-			goto st254
+			goto tr296
+		case 108:
+			goto tr412
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st253:
@@ -10207,29 +10216,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_253:
 		switch lex.data[(lex.p)] {
+		case 73:
+			goto st254
 		case 84:
-			goto tr363
+			goto st255
 		case 96:
-			goto tr294
+			goto tr296
+		case 105:
+			goto st254
 		case 116:
-			goto tr363
+			goto st255
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st254:
@@ -10238,29 +10251,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_254:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto st255
+		case 84:
+			goto tr365
 		case 96:
-			goto tr294
-		case 101:
-			goto st255
+			goto tr296
+		case 116:
+			goto tr365
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st255:
@@ -10269,29 +10282,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_255:
 		switch lex.data[(lex.p)] {
-		case 78:
+		case 69:
 			goto st256
 		case 96:
-			goto tr294
-		case 110:
+			goto tr296
+		case 101:
 			goto st256
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st256:
@@ -10300,29 +10313,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_256:
 		switch lex.data[(lex.p)] {
-		case 68:
+		case 78:
 			goto st257
 		case 96:
-			goto tr294
-		case 100:
+			goto tr296
+		case 110:
 			goto st257
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st257:
@@ -10331,29 +10344,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_257:
 		switch lex.data[(lex.p)] {
-		case 83:
-			goto tr416
+		case 68:
+			goto st258
 		case 96:
-			goto tr294
-		case 115:
-			goto tr416
+			goto tr296
+		case 100:
+			goto st258
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st258:
@@ -10362,37 +10375,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_258:
 		switch lex.data[(lex.p)] {
-		case 73:
-			goto st259
-		case 79:
-			goto st264
-		case 85:
-			goto st187
+		case 83:
+			goto tr418
 		case 96:
-			goto tr294
-		case 105:
-			goto st259
-		case 111:
-			goto st264
-		case 117:
-			goto st187
+			goto tr296
+		case 115:
+			goto tr418
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st259:
@@ -10401,29 +10406,41 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_259:
 		switch lex.data[(lex.p)] {
+		case 73:
+			goto st260
 		case 78:
-			goto st260
+			goto tr420
+		case 79:
+			goto st265
+		case 85:
+			goto st188
 		case 96:
-			goto tr294
-		case 110:
+			goto tr296
+		case 105:
 			goto st260
+		case 110:
+			goto tr420
+		case 111:
+			goto st265
+		case 117:
+			goto st188
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st260:
@@ -10432,29 +10449,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_260:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 78:
 			goto st261
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 110:
 			goto st261
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st261:
@@ -10463,29 +10480,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_261:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 65:
 			goto st262
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 97:
 			goto st262
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st262:
@@ -10497,26 +10514,26 @@ func (lex *Lexer) Lex(lval Lval) int {
 		case 76:
 			goto st263
 		case 96:
-			goto tr422
+			goto tr296
 		case 108:
 			goto st263
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr422
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr422
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr422
+				goto tr296
 			}
 		default:
-			goto tr422
+			goto tr296
 		}
 		goto tr204
 	st263:
@@ -10525,29 +10542,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_263:
 		switch lex.data[(lex.p)] {
-		case 89:
-			goto tr424
+		case 76:
+			goto st264
 		case 96:
-			goto tr294
-		case 121:
-			goto tr424
+			goto tr425
+		case 108:
+			goto st264
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr425
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr425
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr425
 			}
 		default:
-			goto tr294
+			goto tr425
 		}
 		goto tr204
 	st264:
@@ -10556,29 +10573,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_264:
 		switch lex.data[(lex.p)] {
-		case 82:
-			goto st265
+		case 89:
+			goto tr427
 		case 96:
-			goto tr294
-		case 114:
-			goto st265
+			goto tr296
+		case 121:
+			goto tr427
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st265:
@@ -10587,29 +10604,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_265:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 82:
 			goto st266
 		case 96:
-			goto tr426
-		case 101:
+			goto tr296
+		case 114:
 			goto st266
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr426
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr426
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr426
+				goto tr296
 			}
 		default:
-			goto tr426
+			goto tr296
 		}
 		goto tr204
 	st266:
@@ -10618,29 +10635,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_266:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 69:
 			goto st267
 		case 96:
-			goto tr294
-		case 97:
+			goto tr429
+		case 101:
 			goto st267
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr429
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr429
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr429
 			}
 		default:
-			goto tr294
+			goto tr429
 		}
 		goto tr204
 	st267:
@@ -10649,29 +10666,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_267:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 65:
 			goto st268
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 97:
 			goto st268
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st268:
@@ -10680,29 +10697,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_268:
 		switch lex.data[(lex.p)] {
-		case 72:
-			goto tr430
+		case 67:
+			goto st269
 		case 96:
-			goto tr294
-		case 104:
-			goto tr430
+			goto tr296
+		case 99:
+			goto st269
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st269:
@@ -10711,33 +10728,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_269:
 		switch lex.data[(lex.p)] {
-		case 76:
-			goto st270
-		case 79:
-			goto st274
+		case 72:
+			goto tr433
 		case 96:
-			goto tr294
-		case 108:
-			goto st270
-		case 111:
-			goto st274
+			goto tr296
+		case 104:
+			goto tr433
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st270:
@@ -10746,29 +10759,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_270:
 		switch lex.data[(lex.p)] {
+		case 76:
+			goto st271
 		case 79:
-			goto st271
+			goto st275
 		case 96:
-			goto tr294
-		case 111:
+			goto tr296
+		case 108:
 			goto st271
+		case 111:
+			goto st275
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st271:
@@ -10777,29 +10794,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_271:
 		switch lex.data[(lex.p)] {
-		case 66:
+		case 79:
 			goto st272
 		case 96:
-			goto tr294
-		case 98:
+			goto tr296
+		case 111:
 			goto st272
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st272:
@@ -10808,29 +10825,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_272:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 66:
 			goto st273
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 98:
 			goto st273
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st273:
@@ -10839,29 +10856,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_273:
 		switch lex.data[(lex.p)] {
-		case 76:
-			goto tr436
+		case 65:
+			goto st274
 		case 96:
-			goto tr294
-		case 108:
-			goto tr436
+			goto tr296
+		case 97:
+			goto st274
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st274:
@@ -10870,29 +10887,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_274:
 		switch lex.data[(lex.p)] {
-		case 84:
-			goto st275
+		case 76:
+			goto tr439
 		case 96:
-			goto tr294
-		case 116:
-			goto st275
+			goto tr296
+		case 108:
+			goto tr439
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st275:
@@ -10901,29 +10918,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_275:
 		switch lex.data[(lex.p)] {
-		case 79:
-			goto tr438
+		case 84:
+			goto st276
 		case 96:
-			goto tr294
-		case 111:
-			goto tr438
+			goto tr296
+		case 116:
+			goto st276
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st276:
@@ -10932,41 +10949,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_276:
 		switch lex.data[(lex.p)] {
-		case 70:
-			goto tr439
-		case 77:
-			goto st277
-		case 78:
-			goto st285
-		case 83:
-			goto st312
+		case 79:
+			goto tr441
 		case 96:
-			goto tr294
-		case 102:
-			goto tr439
-		case 109:
-			goto st277
-		case 110:
-			goto st285
-		case 115:
-			goto st312
+			goto tr296
+		case 111:
+			goto tr441
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st277:
@@ -10975,29 +10980,41 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_277:
 		switch lex.data[(lex.p)] {
-		case 80:
+		case 70:
+			goto tr442
+		case 77:
 			goto st278
+		case 78:
+			goto st286
+		case 83:
+			goto st313
 		case 96:
-			goto tr294
-		case 112:
+			goto tr296
+		case 102:
+			goto tr442
+		case 109:
 			goto st278
+		case 110:
+			goto st286
+		case 115:
+			goto st313
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st278:
@@ -11006,29 +11023,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_278:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 80:
 			goto st279
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 112:
 			goto st279
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st279:
@@ -11037,29 +11054,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_279:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 76:
 			goto st280
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 108:
 			goto st280
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st280:
@@ -11068,29 +11085,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_280:
 		switch lex.data[(lex.p)] {
-		case 77:
+		case 69:
 			goto st281
 		case 96:
-			goto tr294
-		case 109:
+			goto tr296
+		case 101:
 			goto st281
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st281:
@@ -11099,29 +11116,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_281:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 77:
 			goto st282
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 109:
 			goto st282
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st282:
@@ -11130,29 +11147,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_282:
 		switch lex.data[(lex.p)] {
-		case 78:
+		case 69:
 			goto st283
 		case 96:
-			goto tr294
-		case 110:
+			goto tr296
+		case 101:
 			goto st283
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st283:
@@ -11161,29 +11178,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_283:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 78:
 			goto st284
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 110:
 			goto st284
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st284:
@@ -11192,29 +11209,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_284:
 		switch lex.data[(lex.p)] {
-		case 83:
-			goto tr450
+		case 84:
+			goto st285
 		case 96:
-			goto tr294
-		case 115:
-			goto tr450
+			goto tr296
+		case 116:
+			goto st285
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st285:
@@ -11223,37 +11240,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_285:
 		switch lex.data[(lex.p)] {
-		case 67:
-			goto st286
 		case 83:
-			goto st295
-		case 84:
-			goto st306
+			goto tr453
 		case 96:
-			goto tr294
-		case 99:
-			goto st286
+			goto tr296
 		case 115:
-			goto st295
-		case 116:
-			goto st306
+			goto tr453
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st286:
@@ -11262,29 +11271,37 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_286:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 67:
 			goto st287
+		case 83:
+			goto st296
+		case 84:
+			goto st307
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 99:
 			goto st287
+		case 115:
+			goto st296
+		case 116:
+			goto st307
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st287:
@@ -11293,29 +11310,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_287:
 		switch lex.data[(lex.p)] {
-		case 85:
+		case 76:
 			goto st288
 		case 96:
-			goto tr294
-		case 117:
+			goto tr296
+		case 108:
 			goto st288
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st288:
@@ -11324,29 +11341,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_288:
 		switch lex.data[(lex.p)] {
-		case 68:
+		case 85:
 			goto st289
 		case 96:
-			goto tr294
-		case 100:
+			goto tr296
+		case 117:
 			goto st289
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st289:
@@ -11355,29 +11372,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_289:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 68:
 			goto st290
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 100:
 			goto st290
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st290:
@@ -11385,25 +11402,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof290
 		}
 	st_case_290:
-		if lex.data[(lex.p)] == 95 {
+		switch lex.data[(lex.p)] {
+		case 69:
+			goto st291
+		case 96:
+			goto tr296
+		case 101:
 			goto st291
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr458
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 96:
+			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr458
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr458
+				goto tr296
 			}
 		default:
-			goto tr458
+			goto tr296
 		}
 		goto tr204
 	st291:
@@ -11411,30 +11433,25 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof291
 		}
 	st_case_291:
-		switch lex.data[(lex.p)] {
-		case 79:
-			goto st292
-		case 96:
-			goto tr294
-		case 111:
+		if lex.data[(lex.p)] == 95 {
 			goto st292
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr461
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 94:
+			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr461
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr461
 			}
 		default:
-			goto tr294
+			goto tr461
 		}
 		goto tr204
 	st292:
@@ -11443,29 +11460,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_292:
 		switch lex.data[(lex.p)] {
-		case 78:
+		case 79:
 			goto st293
 		case 96:
-			goto tr294
-		case 110:
+			goto tr296
+		case 111:
 			goto st293
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st293:
@@ -11474,29 +11491,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_293:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 78:
 			goto st294
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 110:
 			goto st294
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st294:
@@ -11505,29 +11522,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_294:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr463
+		case 67:
+			goto st295
 		case 96:
-			goto tr294
-		case 101:
-			goto tr463
+			goto tr296
+		case 99:
+			goto st295
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st295:
@@ -11536,29 +11553,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_295:
 		switch lex.data[(lex.p)] {
-		case 84:
-			goto st296
+		case 69:
+			goto tr466
 		case 96:
-			goto tr294
-		case 116:
-			goto st296
+			goto tr296
+		case 101:
+			goto tr466
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st296:
@@ -11567,33 +11584,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_296:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 84:
 			goto st297
-		case 69:
-			goto st302
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 116:
 			goto st297
-		case 101:
-			goto st302
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st297:
@@ -11602,29 +11615,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_297:
 		switch lex.data[(lex.p)] {
-		case 78:
+		case 65:
 			goto st298
+		case 69:
+			goto st303
 		case 96:
-			goto tr294
-		case 110:
+			goto tr296
+		case 97:
 			goto st298
+		case 101:
+			goto st303
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st298:
@@ -11633,29 +11650,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_298:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 78:
 			goto st299
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 110:
 			goto st299
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st299:
@@ -11664,29 +11681,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_299:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 67:
 			goto st300
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 99:
 			goto st300
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st300:
@@ -11695,29 +11712,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_300:
 		switch lex.data[(lex.p)] {
-		case 79:
+		case 69:
 			goto st301
 		case 96:
-			goto tr294
-		case 111:
+			goto tr296
+		case 101:
 			goto st301
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st301:
@@ -11726,29 +11743,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_301:
 		switch lex.data[(lex.p)] {
-		case 70:
-			goto tr471
+		case 79:
+			goto st302
 		case 96:
-			goto tr294
-		case 102:
-			goto tr471
+			goto tr296
+		case 111:
+			goto st302
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st302:
@@ -11757,29 +11774,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_302:
 		switch lex.data[(lex.p)] {
-		case 65:
-			goto st303
+		case 70:
+			goto tr474
 		case 96:
-			goto tr294
-		case 97:
-			goto st303
+			goto tr296
+		case 102:
+			goto tr474
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st303:
@@ -11788,29 +11805,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_303:
 		switch lex.data[(lex.p)] {
-		case 68:
+		case 65:
 			goto st304
 		case 96:
-			goto tr294
-		case 100:
+			goto tr296
+		case 97:
 			goto st304
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st304:
@@ -11819,29 +11836,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_304:
 		switch lex.data[(lex.p)] {
-		case 79:
+		case 68:
 			goto st305
 		case 96:
-			goto tr294
-		case 111:
+			goto tr296
+		case 100:
 			goto st305
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st305:
@@ -11850,29 +11867,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_305:
 		switch lex.data[(lex.p)] {
-		case 70:
-			goto tr475
+		case 79:
+			goto st306
 		case 96:
-			goto tr294
-		case 102:
-			goto tr475
+			goto tr296
+		case 111:
+			goto st306
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st306:
@@ -11881,29 +11898,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_306:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto st307
+		case 70:
+			goto tr478
 		case 96:
-			goto tr294
-		case 101:
-			goto st307
+			goto tr296
+		case 102:
+			goto tr478
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st307:
@@ -11912,29 +11929,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_307:
 		switch lex.data[(lex.p)] {
-		case 82:
+		case 69:
 			goto st308
 		case 96:
-			goto tr294
-		case 114:
+			goto tr296
+		case 101:
 			goto st308
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st308:
@@ -11943,29 +11960,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_308:
 		switch lex.data[(lex.p)] {
-		case 70:
+		case 82:
 			goto st309
 		case 96:
-			goto tr294
-		case 102:
+			goto tr296
+		case 114:
 			goto st309
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st309:
@@ -11974,29 +11991,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_309:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 70:
 			goto st310
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 102:
 			goto st310
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st310:
@@ -12005,29 +12022,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_310:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 65:
 			goto st311
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 97:
 			goto st311
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st311:
@@ -12036,29 +12053,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_311:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr481
+		case 67:
+			goto st312
 		case 96:
-			goto tr294
-		case 101:
-			goto tr481
+			goto tr296
+		case 99:
+			goto st312
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st312:
@@ -12067,29 +12084,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_312:
 		switch lex.data[(lex.p)] {
-		case 83:
-			goto st313
+		case 69:
+			goto tr484
 		case 96:
-			goto tr294
-		case 115:
-			goto st313
+			goto tr296
+		case 101:
+			goto tr484
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st313:
@@ -12098,29 +12115,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_313:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 83:
 			goto st314
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 115:
 			goto st314
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st314:
@@ -12129,29 +12146,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_314:
 		switch lex.data[(lex.p)] {
-		case 84:
-			goto tr484
+		case 69:
+			goto st315
 		case 96:
-			goto tr294
-		case 116:
-			goto tr484
+			goto tr296
+		case 101:
+			goto st315
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st315:
@@ -12160,29 +12177,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_315:
 		switch lex.data[(lex.p)] {
-		case 73:
-			goto st316
+		case 84:
+			goto tr487
 		case 96:
-			goto tr294
-		case 105:
-			goto st316
+			goto tr296
+		case 116:
+			goto tr487
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st316:
@@ -12191,29 +12208,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_316:
 		switch lex.data[(lex.p)] {
-		case 83:
+		case 73:
 			goto st317
 		case 96:
-			goto tr294
-		case 115:
+			goto tr296
+		case 105:
 			goto st317
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st317:
@@ -12222,29 +12239,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_317:
 		switch lex.data[(lex.p)] {
-		case 84:
-			goto tr487
+		case 83:
+			goto st318
 		case 96:
-			goto tr294
-		case 116:
-			goto tr487
+			goto tr296
+		case 115:
+			goto st318
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st318:
@@ -12253,33 +12270,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_318:
 		switch lex.data[(lex.p)] {
-		case 65:
-			goto st319
-		case 69:
-			goto st326
+		case 84:
+			goto tr490
 		case 96:
-			goto tr294
-		case 97:
-			goto st319
-		case 101:
-			goto st326
+			goto tr296
+		case 116:
+			goto tr490
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st319:
@@ -12288,29 +12301,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_319:
 		switch lex.data[(lex.p)] {
-		case 77:
+		case 65:
 			goto st320
+		case 69:
+			goto st327
 		case 96:
-			goto tr294
-		case 109:
+			goto tr296
+		case 97:
 			goto st320
+		case 101:
+			goto st327
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st320:
@@ -12319,29 +12336,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_320:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 77:
 			goto st321
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 109:
 			goto st321
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st321:
@@ -12350,29 +12367,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_321:
 		switch lex.data[(lex.p)] {
-		case 83:
+		case 69:
 			goto st322
 		case 96:
-			goto tr294
-		case 115:
+			goto tr296
+		case 101:
 			goto st322
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st322:
@@ -12381,29 +12398,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_322:
 		switch lex.data[(lex.p)] {
-		case 80:
+		case 83:
 			goto st323
 		case 96:
-			goto tr294
-		case 112:
+			goto tr296
+		case 115:
 			goto st323
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st323:
@@ -12412,29 +12429,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_323:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 80:
 			goto st324
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 112:
 			goto st324
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st324:
@@ -12443,29 +12460,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_324:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 65:
 			goto st325
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 97:
 			goto st325
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st325:
@@ -12474,29 +12491,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_325:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr496
+		case 67:
+			goto st326
 		case 96:
-			goto tr294
-		case 101:
-			goto tr496
+			goto tr296
+		case 99:
+			goto st326
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st326:
@@ -12505,29 +12522,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_326:
 		switch lex.data[(lex.p)] {
-		case 87:
-			goto tr497
+		case 69:
+			goto tr499
 		case 96:
-			goto tr294
-		case 119:
-			goto tr497
+			goto tr296
+		case 101:
+			goto tr499
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st327:
@@ -12536,29 +12553,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_327:
 		switch lex.data[(lex.p)] {
-		case 82:
-			goto tr498
+		case 87:
+			goto tr500
 		case 96:
-			goto tr294
-		case 114:
-			goto tr498
+			goto tr296
+		case 119:
+			goto tr500
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st328:
@@ -12568,32 +12585,28 @@ func (lex *Lexer) Lex(lval Lval) int {
 	st_case_328:
 		switch lex.data[(lex.p)] {
 		case 82:
-			goto st329
-		case 85:
-			goto st341
+			goto tr501
 		case 96:
-			goto tr294
+			goto tr296
 		case 114:
-			goto st329
-		case 117:
-			goto st341
+			goto tr501
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st329:
@@ -12602,33 +12615,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_329:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 82:
 			goto st330
-		case 79:
-			goto st335
+		case 85:
+			goto st342
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 114:
 			goto st330
-		case 111:
-			goto st335
+		case 117:
+			goto st342
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st330:
@@ -12637,33 +12650,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_330:
 		switch lex.data[(lex.p)] {
-		case 78:
+		case 73:
 			goto st331
-		case 86:
-			goto st332
+		case 79:
+			goto st336
 		case 96:
-			goto tr294
-		case 110:
+			goto tr296
+		case 105:
 			goto st331
-		case 118:
-			goto st332
+		case 111:
+			goto st336
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st331:
@@ -12672,29 +12685,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_331:
 		switch lex.data[(lex.p)] {
-		case 84:
-			goto tr505
+		case 78:
+			goto st332
+		case 86:
+			goto st333
 		case 96:
-			goto tr294
-		case 116:
-			goto tr505
+			goto tr296
+		case 110:
+			goto st332
+		case 118:
+			goto st333
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st332:
@@ -12703,29 +12720,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_332:
 		switch lex.data[(lex.p)] {
-		case 65:
-			goto st333
+		case 84:
+			goto tr508
 		case 96:
-			goto tr294
-		case 97:
-			goto st333
+			goto tr296
+		case 116:
+			goto tr508
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st333:
@@ -12734,29 +12751,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_333:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 65:
 			goto st334
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 97:
 			goto st334
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st334:
@@ -12765,29 +12782,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_334:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr508
+		case 84:
+			goto st335
 		case 96:
-			goto tr294
-		case 101:
-			goto tr508
+			goto tr296
+		case 116:
+			goto st335
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st335:
@@ -12796,29 +12813,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_335:
 		switch lex.data[(lex.p)] {
-		case 84:
-			goto st336
+		case 69:
+			goto tr511
 		case 96:
-			goto tr294
-		case 116:
-			goto st336
+			goto tr296
+		case 101:
+			goto tr511
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st336:
@@ -12827,29 +12844,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_336:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 84:
 			goto st337
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 116:
 			goto st337
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st337:
@@ -12858,29 +12875,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_337:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 69:
 			goto st338
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 101:
 			goto st338
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st338:
@@ -12889,29 +12906,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_338:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 67:
 			goto st339
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 99:
 			goto st339
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st339:
@@ -12920,29 +12937,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_339:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 84:
 			goto st340
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 116:
 			goto st340
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st340:
@@ -12951,29 +12968,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_340:
 		switch lex.data[(lex.p)] {
-		case 68:
-			goto tr514
+		case 69:
+			goto st341
 		case 96:
-			goto tr294
-		case 100:
-			goto tr514
+			goto tr296
+		case 101:
+			goto st341
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st341:
@@ -12982,29 +12999,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_341:
 		switch lex.data[(lex.p)] {
-		case 66:
-			goto st342
+		case 68:
+			goto tr517
 		case 96:
-			goto tr294
-		case 98:
-			goto st342
+			goto tr296
+		case 100:
+			goto tr517
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st342:
@@ -13013,29 +13030,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_342:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 66:
 			goto st343
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 98:
 			goto st343
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st343:
@@ -13044,29 +13061,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_343:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 76:
 			goto st344
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 108:
 			goto st344
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st344:
@@ -13075,29 +13092,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_344:
 		switch lex.data[(lex.p)] {
-		case 67:
-			goto tr518
+		case 73:
+			goto st345
 		case 96:
-			goto tr294
-		case 99:
-			goto tr518
+			goto tr296
+		case 105:
+			goto st345
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st345:
@@ -13106,29 +13123,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_345:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto st346
+		case 67:
+			goto tr521
 		case 96:
-			goto tr294
-		case 101:
-			goto st346
+			goto tr296
+		case 99:
+			goto tr521
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st346:
@@ -13137,33 +13154,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_346:
 		switch lex.data[(lex.p)] {
-		case 81:
+		case 69:
 			goto st347
-		case 84:
-			goto st356
 		case 96:
-			goto tr294
-		case 113:
+			goto tr296
+		case 101:
 			goto st347
-		case 116:
-			goto st356
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st347:
@@ -13172,29 +13185,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_347:
 		switch lex.data[(lex.p)] {
-		case 85:
+		case 81:
 			goto st348
+		case 84:
+			goto st357
 		case 96:
-			goto tr294
-		case 117:
+			goto tr296
+		case 113:
 			goto st348
+		case 116:
+			goto st357
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st348:
@@ -13203,29 +13220,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_348:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 85:
 			goto st349
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 117:
 			goto st349
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st349:
@@ -13234,29 +13251,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_349:
 		switch lex.data[(lex.p)] {
-		case 82:
+		case 73:
 			goto st350
 		case 96:
-			goto tr294
-		case 114:
+			goto tr296
+		case 105:
 			goto st350
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st350:
@@ -13265,29 +13282,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_350:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 82:
 			goto st351
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 114:
 			goto st351
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st351:
@@ -13295,25 +13312,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof351
 		}
 	st_case_351:
-		if lex.data[(lex.p)] == 95 {
+		switch lex.data[(lex.p)] {
+		case 69:
+			goto st352
+		case 96:
+			goto tr296
+		case 101:
 			goto st352
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr526
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 96:
+			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr526
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr526
+				goto tr296
 			}
 		default:
-			goto tr526
+			goto tr296
 		}
 		goto tr204
 	st352:
@@ -13321,30 +13343,25 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof352
 		}
 	st_case_352:
-		switch lex.data[(lex.p)] {
-		case 79:
-			goto st353
-		case 96:
-			goto tr294
-		case 111:
+		if lex.data[(lex.p)] == 95 {
 			goto st353
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr529
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 94:
+			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr529
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr529
 			}
 		default:
-			goto tr294
+			goto tr529
 		}
 		goto tr204
 	st353:
@@ -13353,29 +13370,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_353:
 		switch lex.data[(lex.p)] {
-		case 78:
+		case 79:
 			goto st354
 		case 96:
-			goto tr294
-		case 110:
+			goto tr296
+		case 111:
 			goto st354
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st354:
@@ -13384,29 +13401,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_354:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 78:
 			goto st355
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 110:
 			goto st355
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st355:
@@ -13415,29 +13432,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_355:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr531
+		case 67:
+			goto st356
 		case 96:
-			goto tr294
-		case 101:
-			goto tr531
+			goto tr296
+		case 99:
+			goto st356
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st356:
@@ -13446,29 +13463,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_356:
 		switch lex.data[(lex.p)] {
-		case 85:
-			goto st357
+		case 69:
+			goto tr534
 		case 96:
-			goto tr294
-		case 117:
-			goto st357
+			goto tr296
+		case 101:
+			goto tr534
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st357:
@@ -13477,29 +13494,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_357:
 		switch lex.data[(lex.p)] {
-		case 82:
+		case 85:
 			goto st358
 		case 96:
-			goto tr294
-		case 114:
+			goto tr296
+		case 117:
 			goto st358
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st358:
@@ -13508,29 +13525,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_358:
 		switch lex.data[(lex.p)] {
-		case 78:
-			goto tr534
+		case 82:
+			goto st359
 		case 96:
-			goto tr294
-		case 110:
-			goto tr534
+			goto tr296
+		case 114:
+			goto st359
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st359:
@@ -13539,33 +13556,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_359:
 		switch lex.data[(lex.p)] {
-		case 84:
-			goto st360
-		case 87:
-			goto st364
+		case 78:
+			goto tr537
 		case 96:
-			goto tr294
-		case 116:
-			goto st360
-		case 119:
-			goto st364
+			goto tr296
+		case 110:
+			goto tr537
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st360:
@@ -13574,29 +13587,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_360:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 84:
 			goto st361
+		case 87:
+			goto st365
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 116:
 			goto st361
+		case 119:
+			goto st365
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st361:
@@ -13605,29 +13622,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_361:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 65:
 			goto st362
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 97:
 			goto st362
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st362:
@@ -13636,29 +13653,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_362:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 84:
 			goto st363
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 116:
 			goto st363
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st363:
@@ -13667,29 +13684,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_363:
 		switch lex.data[(lex.p)] {
-		case 67:
-			goto tr540
+		case 73:
+			goto st364
 		case 96:
-			goto tr294
-		case 99:
-			goto tr540
+			goto tr296
+		case 105:
+			goto st364
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st364:
@@ -13698,29 +13715,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_364:
 		switch lex.data[(lex.p)] {
-		case 73:
-			goto st365
+		case 67:
+			goto tr543
 		case 96:
-			goto tr294
-		case 105:
-			goto st365
+			goto tr296
+		case 99:
+			goto tr543
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st365:
@@ -13729,29 +13746,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_365:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 73:
 			goto st366
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 105:
 			goto st366
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st366:
@@ -13760,29 +13777,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_366:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 84:
 			goto st367
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 116:
 			goto st367
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st367:
@@ -13791,29 +13808,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_367:
 		switch lex.data[(lex.p)] {
-		case 72:
-			goto tr544
+		case 67:
+			goto st368
 		case 96:
-			goto tr294
-		case 104:
-			goto tr544
+			goto tr296
+		case 99:
+			goto st368
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st368:
@@ -13823,32 +13840,28 @@ func (lex *Lexer) Lex(lval Lval) int {
 	st_case_368:
 		switch lex.data[(lex.p)] {
 		case 72:
-			goto st369
-		case 82:
-			goto st372
+			goto tr547
 		case 96:
-			goto tr294
+			goto tr296
 		case 104:
-			goto st369
-		case 114:
-			goto st372
+			goto tr547
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st369:
@@ -13857,29 +13870,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_369:
 		switch lex.data[(lex.p)] {
+		case 72:
+			goto st370
 		case 82:
-			goto st370
+			goto st373
 		case 96:
-			goto tr294
-		case 114:
+			goto tr296
+		case 104:
 			goto st370
+		case 114:
+			goto st373
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st370:
@@ -13888,29 +13905,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_370:
 		switch lex.data[(lex.p)] {
-		case 79:
+		case 82:
 			goto st371
 		case 96:
-			goto tr294
-		case 111:
+			goto tr296
+		case 114:
 			goto st371
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st371:
@@ -13919,29 +13936,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_371:
 		switch lex.data[(lex.p)] {
-		case 87:
-			goto tr549
+		case 79:
+			goto st372
 		case 96:
-			goto tr294
-		case 119:
-			goto tr549
+			goto tr296
+		case 111:
+			goto st372
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st372:
@@ -13950,33 +13967,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_372:
 		switch lex.data[(lex.p)] {
-		case 65:
-			goto st373
-		case 89:
-			goto tr551
+		case 87:
+			goto tr552
 		case 96:
-			goto tr294
-		case 97:
-			goto st373
-		case 121:
-			goto tr551
+			goto tr296
+		case 119:
+			goto tr552
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st373:
@@ -13985,29 +13998,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_373:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 65:
 			goto st374
+		case 89:
+			goto tr554
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 97:
 			goto st374
+		case 121:
+			goto tr554
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st374:
@@ -14016,29 +14033,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_374:
 		switch lex.data[(lex.p)] {
-		case 84:
-			goto tr553
+		case 73:
+			goto st375
 		case 96:
-			goto tr294
-		case 116:
-			goto tr553
+			goto tr296
+		case 105:
+			goto st375
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st375:
@@ -14047,33 +14064,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_375:
 		switch lex.data[(lex.p)] {
-		case 78:
-			goto st376
-		case 83:
-			goto st379
+		case 84:
+			goto tr556
 		case 96:
-			goto tr294
-		case 110:
-			goto st376
-		case 115:
-			goto st379
+			goto tr296
+		case 116:
+			goto tr556
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st376:
@@ -14082,29 +14095,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_376:
 		switch lex.data[(lex.p)] {
+		case 78:
+			goto st377
 		case 83:
-			goto st377
+			goto st380
 		case 96:
-			goto tr294
-		case 115:
+			goto tr296
+		case 110:
 			goto st377
+		case 115:
+			goto st380
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st377:
@@ -14113,29 +14130,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_377:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 83:
 			goto st378
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 115:
 			goto st378
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st378:
@@ -14144,29 +14161,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_378:
 		switch lex.data[(lex.p)] {
-		case 84:
-			goto tr558
+		case 69:
+			goto st379
 		case 96:
-			goto tr294
-		case 116:
-			goto tr558
+			goto tr296
+		case 101:
+			goto st379
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st379:
@@ -14175,29 +14192,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_379:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr559
+		case 84:
+			goto tr561
 		case 96:
-			goto tr294
-		case 101:
-			goto tr559
+			goto tr296
+		case 116:
+			goto tr561
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st380:
@@ -14206,29 +14223,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_380:
 		switch lex.data[(lex.p)] {
-		case 65:
-			goto st381
+		case 69:
+			goto tr562
 		case 96:
-			goto tr294
-		case 97:
-			goto st381
+			goto tr296
+		case 101:
+			goto tr562
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st381:
@@ -14237,29 +14254,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_381:
 		switch lex.data[(lex.p)] {
-		case 82:
-			goto tr561
+		case 65:
+			goto st382
 		case 96:
-			goto tr294
-		case 114:
-			goto tr561
+			goto tr296
+		case 97:
+			goto st382
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st382:
@@ -14268,29 +14285,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_382:
 		switch lex.data[(lex.p)] {
-		case 72:
-			goto st383
+		case 82:
+			goto tr564
 		case 96:
-			goto tr294
-		case 104:
-			goto st383
+			goto tr296
+		case 114:
+			goto tr564
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st383:
@@ -14299,29 +14316,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_383:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 72:
 			goto st384
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 104:
 			goto st384
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st384:
@@ -14330,29 +14347,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_384:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 73:
 			goto st385
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 105:
 			goto st385
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st385:
@@ -14361,29 +14378,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_385:
 		switch lex.data[(lex.p)] {
-		case 69:
-			goto tr565
+		case 76:
+			goto st386
 		case 96:
-			goto tr294
-		case 101:
-			goto tr565
+			goto tr296
+		case 108:
+			goto st386
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st386:
@@ -14392,29 +14409,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_386:
 		switch lex.data[(lex.p)] {
-		case 79:
-			goto st387
+		case 69:
+			goto tr568
 		case 96:
-			goto tr294
-		case 111:
-			goto st387
+			goto tr296
+		case 101:
+			goto tr568
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st387:
@@ -14423,29 +14440,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_387:
 		switch lex.data[(lex.p)] {
-		case 82:
-			goto tr567
+		case 79:
+			goto st388
 		case 96:
-			goto tr294
-		case 114:
-			goto tr567
+			goto tr296
+		case 111:
+			goto st388
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st388:
@@ -14454,29 +14471,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_388:
 		switch lex.data[(lex.p)] {
-		case 73:
-			goto st389
+		case 82:
+			goto tr570
 		case 96:
-			goto tr294
-		case 105:
-			goto st389
+			goto tr296
+		case 114:
+			goto tr570
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st389:
@@ -14485,29 +14502,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_389:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 73:
 			goto st390
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 105:
 			goto st390
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st390:
@@ -14516,29 +14533,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_390:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 69:
 			goto st391
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 101:
 			goto st391
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st391:
@@ -14547,42 +14564,73 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_391:
 		switch lex.data[(lex.p)] {
-		case 68:
-			goto tr571
+		case 76:
+			goto st392
 		case 96:
-			goto tr294
-		case 100:
-			goto tr571
+			goto tr296
+		case 108:
+			goto st392
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
-	tr571:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-		goto st392
 	st392:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof392
 		}
 	st_case_392:
-//line scanner/scanner.go:13461
+		switch lex.data[(lex.p)] {
+		case 68:
+			goto tr574
+		case 96:
+			goto tr296
+		case 100:
+			goto tr574
+		}
+		switch {
+		case lex.data[(lex.p)] < 58:
+			if lex.data[(lex.p)] <= 47 {
+				goto tr296
+			}
+		case lex.data[(lex.p)] > 64:
+			switch {
+			case lex.data[(lex.p)] > 94:
+				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
+					goto tr296
+				}
+			case lex.data[(lex.p)] >= 91:
+				goto tr296
+			}
+		default:
+			goto tr296
+		}
+		goto tr204
+	tr574:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+		goto st393
+	st393:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof393
+		}
+	st_case_393:
+//line scanner/scanner.go:13494
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st93
@@ -14591,11 +14639,11 @@ func (lex *Lexer) Lex(lval Lval) int {
 		case 32:
 			goto st92
 		case 70:
-			goto st393
+			goto st394
 		case 96:
-			goto tr572
+			goto tr575
 		case 102:
-			goto st393
+			goto st394
 		}
 		switch {
 		case lex.data[(lex.p)] < 14:
@@ -14605,23 +14653,23 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto st92
 				}
 			default:
-				goto tr572
+				goto tr575
 			}
 		case lex.data[(lex.p)] > 47:
 			switch {
 			case lex.data[(lex.p)] < 91:
 				if 58 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 64 {
-					goto tr572
+					goto tr575
 				}
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr572
+					goto tr575
 				}
 			default:
-				goto tr572
+				goto tr575
 			}
 		default:
-			goto tr572
+			goto tr575
 		}
 		goto tr204
 	tr131:
@@ -14633,7 +14681,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof92
 		}
 	st_case_92:
-//line scanner/scanner.go:13512
+//line scanner/scanner.go:13545
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto st93
@@ -14659,7 +14707,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof93
 		}
 	st_case_93:
-//line scanner/scanner.go:13538
+//line scanner/scanner.go:13571
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr132
@@ -14685,7 +14733,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof94
 		}
 	st_case_94:
-//line scanner/scanner.go:13564
+//line scanner/scanner.go:13597
 		if lex.data[(lex.p)] == 10 {
 			goto st93
 		}
@@ -14699,7 +14747,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof95
 		}
 	st_case_95:
-//line scanner/scanner.go:13578
+//line scanner/scanner.go:13611
 		switch lex.data[(lex.p)] {
 		case 82:
 			goto st96
@@ -14731,66 +14779,35 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto tr137
 		}
 		goto tr126
-	st393:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof393
-		}
-	st_case_393:
-		switch lex.data[(lex.p)] {
-		case 82:
-			goto st394
-		case 96:
-			goto tr294
-		case 114:
-			goto st394
-		}
-		switch {
-		case lex.data[(lex.p)] < 58:
-			if lex.data[(lex.p)] <= 47 {
-				goto tr294
-			}
-		case lex.data[(lex.p)] > 64:
-			switch {
-			case lex.data[(lex.p)] > 94:
-				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
-				}
-			case lex.data[(lex.p)] >= 91:
-				goto tr294
-			}
-		default:
-			goto tr294
-		}
-		goto tr204
 	st394:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof394
 		}
 	st_case_394:
 		switch lex.data[(lex.p)] {
-		case 79:
+		case 82:
 			goto st395
 		case 96:
-			goto tr294
-		case 111:
+			goto tr296
+		case 114:
 			goto st395
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st395:
@@ -14799,29 +14816,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_395:
 		switch lex.data[(lex.p)] {
-		case 77:
-			goto tr576
+		case 79:
+			goto st396
 		case 96:
-			goto tr294
-		case 109:
-			goto tr576
+			goto tr296
+		case 111:
+			goto st396
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st396:
@@ -14829,93 +14846,65 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof396
 		}
 	st_case_396:
-		if lex.data[(lex.p)] == 61 {
-			goto tr577
-		}
-		goto tr232
-	st397:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof397
-		}
-	st_case_397:
-		if lex.data[(lex.p)] == 95 {
-			goto st398
-		}
-		switch {
-		case lex.data[(lex.p)] < 58:
-			if lex.data[(lex.p)] <= 47 {
-				goto tr294
-			}
-		case lex.data[(lex.p)] > 64:
-			switch {
-			case lex.data[(lex.p)] > 96:
-				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
-				}
-			case lex.data[(lex.p)] >= 91:
-				goto tr294
-			}
-		default:
-			goto tr294
-		}
-		goto tr204
-	st398:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof398
-		}
-	st_case_398:
 		switch lex.data[(lex.p)] {
-		case 67:
-			goto st399
-		case 68:
-			goto st405
-		case 70:
-			goto st409
-		case 72:
-			goto st422
-		case 76:
-			goto st434
 		case 77:
-			goto st439
-		case 78:
-			goto st446
-		case 84:
-			goto st456
+			goto tr579
 		case 96:
-			goto tr294
-		case 99:
-			goto st399
-		case 100:
-			goto st405
-		case 102:
-			goto st409
-		case 104:
-			goto st422
-		case 108:
-			goto st434
+			goto tr296
 		case 109:
-			goto st439
-		case 110:
-			goto st446
-		case 116:
-			goto st456
+			goto tr579
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
+		}
+		goto tr204
+	st397:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof397
+		}
+	st_case_397:
+		if lex.data[(lex.p)] == 61 {
+			goto tr580
+		}
+		goto tr232
+	st398:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof398
+		}
+	st_case_398:
+		if lex.data[(lex.p)] == 95 {
+			goto st399
+		}
+		switch {
+		case lex.data[(lex.p)] < 58:
+			if lex.data[(lex.p)] <= 47 {
+				goto tr296
+			}
+		case lex.data[(lex.p)] > 64:
+			switch {
+			case lex.data[(lex.p)] > 96:
+				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
+					goto tr296
+				}
+			case lex.data[(lex.p)] >= 91:
+				goto tr296
+			}
+		default:
+			goto tr296
 		}
 		goto tr204
 	st399:
@@ -14924,29 +14913,57 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_399:
 		switch lex.data[(lex.p)] {
+		case 67:
+			goto st400
+		case 68:
+			goto st406
+		case 70:
+			goto st410
+		case 72:
+			goto st423
 		case 76:
-			goto st400
+			goto st435
+		case 77:
+			goto st440
+		case 78:
+			goto st447
+		case 84:
+			goto st457
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 99:
 			goto st400
+		case 100:
+			goto st406
+		case 102:
+			goto st410
+		case 104:
+			goto st423
+		case 108:
+			goto st435
+		case 109:
+			goto st440
+		case 110:
+			goto st447
+		case 116:
+			goto st457
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st400:
@@ -14955,29 +14972,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_400:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 76:
 			goto st401
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 108:
 			goto st401
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st401:
@@ -14986,29 +15003,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_401:
 		switch lex.data[(lex.p)] {
-		case 83:
+		case 65:
 			goto st402
 		case 96:
-			goto tr294
-		case 115:
+			goto tr296
+		case 97:
 			goto st402
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st402:
@@ -15020,26 +15037,26 @@ func (lex *Lexer) Lex(lval Lval) int {
 		case 83:
 			goto st403
 		case 96:
-			goto tr294
+			goto tr296
 		case 115:
 			goto st403
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st403:
@@ -15047,25 +15064,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof403
 		}
 	st_case_403:
-		if lex.data[(lex.p)] == 95 {
+		switch lex.data[(lex.p)] {
+		case 83:
+			goto st404
+		case 96:
+			goto tr296
+		case 115:
 			goto st404
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 96:
+			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st404:
@@ -15074,24 +15096,24 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_404:
 		if lex.data[(lex.p)] == 95 {
-			goto tr592
+			goto st405
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st405:
@@ -15099,30 +15121,25 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof405
 		}
 	st_case_405:
-		switch lex.data[(lex.p)] {
-		case 73:
-			goto st406
-		case 96:
-			goto tr294
-		case 105:
-			goto st406
+		if lex.data[(lex.p)] == 95 {
+			goto tr595
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 94:
+			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st406:
@@ -15131,29 +15148,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_406:
 		switch lex.data[(lex.p)] {
-		case 82:
+		case 73:
 			goto st407
 		case 96:
-			goto tr294
-		case 114:
+			goto tr296
+		case 105:
 			goto st407
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st407:
@@ -15161,25 +15178,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof407
 		}
 	st_case_407:
-		if lex.data[(lex.p)] == 95 {
+		switch lex.data[(lex.p)] {
+		case 82:
+			goto st408
+		case 96:
+			goto tr296
+		case 114:
 			goto st408
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 96:
+			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st408:
@@ -15188,24 +15210,24 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_408:
 		if lex.data[(lex.p)] == 95 {
-			goto tr596
+			goto st409
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st409:
@@ -15213,34 +15235,25 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof409
 		}
 	st_case_409:
-		switch lex.data[(lex.p)] {
-		case 73:
-			goto st410
-		case 85:
-			goto st414
-		case 96:
-			goto tr294
-		case 105:
-			goto st410
-		case 117:
-			goto st414
+		if lex.data[(lex.p)] == 95 {
+			goto tr599
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 94:
+			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st410:
@@ -15249,29 +15262,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_410:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 73:
 			goto st411
+		case 85:
+			goto st415
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 105:
 			goto st411
+		case 117:
+			goto st415
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st411:
@@ -15280,29 +15297,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_411:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 76:
 			goto st412
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 108:
 			goto st412
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st412:
@@ -15310,25 +15327,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof412
 		}
 	st_case_412:
-		if lex.data[(lex.p)] == 95 {
+		switch lex.data[(lex.p)] {
+		case 69:
+			goto st413
+		case 96:
+			goto tr296
+		case 101:
 			goto st413
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 96:
+			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st413:
@@ -15337,24 +15359,24 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_413:
 		if lex.data[(lex.p)] == 95 {
-			goto tr602
+			goto st414
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st414:
@@ -15362,30 +15384,25 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof414
 		}
 	st_case_414:
-		switch lex.data[(lex.p)] {
-		case 78:
-			goto st415
-		case 96:
-			goto tr294
-		case 110:
-			goto st415
+		if lex.data[(lex.p)] == 95 {
+			goto tr605
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 94:
+			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st415:
@@ -15394,29 +15411,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_415:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 78:
 			goto st416
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 110:
 			goto st416
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st416:
@@ -15425,29 +15442,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_416:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 67:
 			goto st417
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 99:
 			goto st417
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st417:
@@ -15456,29 +15473,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_417:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 84:
 			goto st418
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 116:
 			goto st418
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st418:
@@ -15487,29 +15504,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_418:
 		switch lex.data[(lex.p)] {
-		case 79:
+		case 73:
 			goto st419
 		case 96:
-			goto tr294
-		case 111:
+			goto tr296
+		case 105:
 			goto st419
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st419:
@@ -15518,29 +15535,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_419:
 		switch lex.data[(lex.p)] {
-		case 78:
+		case 79:
 			goto st420
 		case 96:
-			goto tr294
-		case 110:
+			goto tr296
+		case 111:
 			goto st420
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st420:
@@ -15548,25 +15565,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof420
 		}
 	st_case_420:
-		if lex.data[(lex.p)] == 95 {
+		switch lex.data[(lex.p)] {
+		case 78:
+			goto st421
+		case 96:
+			goto tr296
+		case 110:
 			goto st421
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 96:
+			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st421:
@@ -15575,24 +15597,24 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_421:
 		if lex.data[(lex.p)] == 95 {
-			goto tr610
+			goto st422
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st422:
@@ -15600,30 +15622,25 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof422
 		}
 	st_case_422:
-		switch lex.data[(lex.p)] {
-		case 65:
-			goto st423
-		case 96:
-			goto tr294
-		case 97:
-			goto st423
+		if lex.data[(lex.p)] == 95 {
+			goto tr613
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 94:
+			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st423:
@@ -15632,29 +15649,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_423:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 65:
 			goto st424
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 97:
 			goto st424
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st424:
@@ -15663,29 +15680,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_424:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 76:
 			goto st425
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 108:
 			goto st425
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st425:
@@ -15693,25 +15710,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof425
 		}
 	st_case_425:
-		if lex.data[(lex.p)] == 95 {
+		switch lex.data[(lex.p)] {
+		case 84:
+			goto st426
+		case 96:
+			goto tr296
+		case 116:
 			goto st426
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 96:
+			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st426:
@@ -15719,30 +15741,25 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof426
 		}
 	st_case_426:
-		switch lex.data[(lex.p)] {
-		case 67:
-			goto st427
-		case 96:
-			goto tr294
-		case 99:
+		if lex.data[(lex.p)] == 95 {
 			goto st427
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 94:
+			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st427:
@@ -15751,29 +15768,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_427:
 		switch lex.data[(lex.p)] {
-		case 79:
+		case 67:
 			goto st428
 		case 96:
-			goto tr294
-		case 111:
+			goto tr296
+		case 99:
 			goto st428
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st428:
@@ -15782,29 +15799,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_428:
 		switch lex.data[(lex.p)] {
-		case 77:
+		case 79:
 			goto st429
 		case 96:
-			goto tr294
-		case 109:
+			goto tr296
+		case 111:
 			goto st429
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st429:
@@ -15813,29 +15830,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_429:
 		switch lex.data[(lex.p)] {
-		case 80:
+		case 77:
 			goto st430
 		case 96:
-			goto tr294
-		case 112:
+			goto tr296
+		case 109:
 			goto st430
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st430:
@@ -15844,29 +15861,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_430:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 80:
 			goto st431
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 112:
 			goto st431
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st431:
@@ -15875,29 +15892,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_431:
 		switch lex.data[(lex.p)] {
-		case 76:
+		case 73:
 			goto st432
 		case 96:
-			goto tr294
-		case 108:
+			goto tr296
+		case 105:
 			goto st432
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st432:
@@ -15906,29 +15923,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_432:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 76:
 			goto st433
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 108:
 			goto st433
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st433:
@@ -15937,29 +15954,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_433:
 		switch lex.data[(lex.p)] {
-		case 82:
-			goto tr622
+		case 69:
+			goto st434
 		case 96:
-			goto tr294
-		case 114:
-			goto tr622
+			goto tr296
+		case 101:
+			goto st434
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st434:
@@ -15968,29 +15985,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_434:
 		switch lex.data[(lex.p)] {
-		case 73:
-			goto st435
+		case 82:
+			goto tr625
 		case 96:
-			goto tr294
-		case 105:
-			goto st435
+			goto tr296
+		case 114:
+			goto tr625
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st435:
@@ -15999,29 +16016,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_435:
 		switch lex.data[(lex.p)] {
-		case 78:
+		case 73:
 			goto st436
 		case 96:
-			goto tr294
-		case 110:
+			goto tr296
+		case 105:
 			goto st436
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st436:
@@ -16030,29 +16047,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_436:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 78:
 			goto st437
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 110:
 			goto st437
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st437:
@@ -16060,25 +16077,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof437
 		}
 	st_case_437:
-		if lex.data[(lex.p)] == 95 {
+		switch lex.data[(lex.p)] {
+		case 69:
+			goto st438
+		case 96:
+			goto tr296
+		case 101:
 			goto st438
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 96:
+			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st438:
@@ -16087,24 +16109,24 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_438:
 		if lex.data[(lex.p)] == 95 {
-			goto tr627
+			goto st439
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st439:
@@ -16112,30 +16134,25 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof439
 		}
 	st_case_439:
-		switch lex.data[(lex.p)] {
-		case 69:
-			goto st440
-		case 96:
-			goto tr294
-		case 101:
-			goto st440
+		if lex.data[(lex.p)] == 95 {
+			goto tr630
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 94:
+			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st440:
@@ -16144,29 +16161,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_440:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 69:
 			goto st441
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 101:
 			goto st441
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st441:
@@ -16175,29 +16192,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_441:
 		switch lex.data[(lex.p)] {
-		case 72:
+		case 84:
 			goto st442
 		case 96:
-			goto tr294
-		case 104:
+			goto tr296
+		case 116:
 			goto st442
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st442:
@@ -16206,29 +16223,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_442:
 		switch lex.data[(lex.p)] {
-		case 79:
+		case 72:
 			goto st443
 		case 96:
-			goto tr294
-		case 111:
+			goto tr296
+		case 104:
 			goto st443
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st443:
@@ -16237,29 +16254,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_443:
 		switch lex.data[(lex.p)] {
-		case 68:
+		case 79:
 			goto st444
 		case 96:
-			goto tr294
-		case 100:
+			goto tr296
+		case 111:
 			goto st444
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st444:
@@ -16267,25 +16284,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof444
 		}
 	st_case_444:
-		if lex.data[(lex.p)] == 95 {
+		switch lex.data[(lex.p)] {
+		case 68:
+			goto st445
+		case 96:
+			goto tr296
+		case 100:
 			goto st445
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 96:
+			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st445:
@@ -16294,24 +16316,24 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_445:
 		if lex.data[(lex.p)] == 95 {
-			goto tr634
+			goto st446
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st446:
@@ -16319,30 +16341,25 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof446
 		}
 	st_case_446:
-		switch lex.data[(lex.p)] {
-		case 65:
-			goto st447
-		case 96:
-			goto tr294
-		case 97:
-			goto st447
+		if lex.data[(lex.p)] == 95 {
+			goto tr637
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 94:
+			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st447:
@@ -16351,29 +16368,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_447:
 		switch lex.data[(lex.p)] {
-		case 77:
+		case 65:
 			goto st448
 		case 96:
-			goto tr294
-		case 109:
+			goto tr296
+		case 97:
 			goto st448
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st448:
@@ -16382,29 +16399,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_448:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 77:
 			goto st449
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 109:
 			goto st449
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st449:
@@ -16413,29 +16430,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_449:
 		switch lex.data[(lex.p)] {
-		case 83:
+		case 69:
 			goto st450
 		case 96:
-			goto tr294
-		case 115:
+			goto tr296
+		case 101:
 			goto st450
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st450:
@@ -16444,29 +16461,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_450:
 		switch lex.data[(lex.p)] {
-		case 80:
+		case 83:
 			goto st451
 		case 96:
-			goto tr294
-		case 112:
+			goto tr296
+		case 115:
 			goto st451
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st451:
@@ -16475,29 +16492,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_451:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 80:
 			goto st452
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 112:
 			goto st452
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st452:
@@ -16506,29 +16523,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_452:
 		switch lex.data[(lex.p)] {
-		case 67:
+		case 65:
 			goto st453
 		case 96:
-			goto tr294
-		case 99:
+			goto tr296
+		case 97:
 			goto st453
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st453:
@@ -16537,29 +16554,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_453:
 		switch lex.data[(lex.p)] {
-		case 69:
+		case 67:
 			goto st454
 		case 96:
-			goto tr294
-		case 101:
+			goto tr296
+		case 99:
 			goto st454
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st454:
@@ -16567,25 +16584,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof454
 		}
 	st_case_454:
-		if lex.data[(lex.p)] == 95 {
+		switch lex.data[(lex.p)] {
+		case 69:
+			goto st455
+		case 96:
+			goto tr296
+		case 101:
 			goto st455
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 96:
+			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st455:
@@ -16594,24 +16616,24 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_455:
 		if lex.data[(lex.p)] == 95 {
-			goto tr644
+			goto st456
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st456:
@@ -16619,30 +16641,25 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof456
 		}
 	st_case_456:
-		switch lex.data[(lex.p)] {
-		case 82:
-			goto st457
-		case 96:
-			goto tr294
-		case 114:
-			goto st457
+		if lex.data[(lex.p)] == 95 {
+			goto tr647
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 94:
+			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st457:
@@ -16651,29 +16668,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_457:
 		switch lex.data[(lex.p)] {
-		case 65:
+		case 82:
 			goto st458
 		case 96:
-			goto tr294
-		case 97:
+			goto tr296
+		case 114:
 			goto st458
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st458:
@@ -16682,29 +16699,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_458:
 		switch lex.data[(lex.p)] {
-		case 73:
+		case 65:
 			goto st459
 		case 96:
-			goto tr294
-		case 105:
+			goto tr296
+		case 97:
 			goto st459
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st459:
@@ -16713,29 +16730,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_459:
 		switch lex.data[(lex.p)] {
-		case 84:
+		case 73:
 			goto st460
 		case 96:
-			goto tr294
-		case 116:
+			goto tr296
+		case 105:
 			goto st460
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st460:
@@ -16743,25 +16760,30 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof460
 		}
 	st_case_460:
-		if lex.data[(lex.p)] == 95 {
+		switch lex.data[(lex.p)] {
+		case 84:
+			goto st461
+		case 96:
+			goto tr296
+		case 116:
 			goto st461
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
-			case lex.data[(lex.p)] > 96:
+			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st461:
@@ -16770,24 +16792,24 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	st_case_461:
 		if lex.data[(lex.p)] == 95 {
-			goto tr650
+			goto st462
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr294
+				goto tr296
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 96:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr294
+					goto tr296
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr294
+				goto tr296
 			}
 		default:
-			goto tr294
+			goto tr296
 		}
 		goto tr204
 	st462:
@@ -16795,22 +16817,48 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof462
 		}
 	st_case_462:
+		if lex.data[(lex.p)] == 95 {
+			goto tr653
+		}
+		switch {
+		case lex.data[(lex.p)] < 58:
+			if lex.data[(lex.p)] <= 47 {
+				goto tr296
+			}
+		case lex.data[(lex.p)] > 64:
+			switch {
+			case lex.data[(lex.p)] > 96:
+				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
+					goto tr296
+				}
+			case lex.data[(lex.p)] >= 91:
+				goto tr296
+			}
+		default:
+			goto tr296
+		}
+		goto tr204
+	st463:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof463
+		}
+	st_case_463:
 		switch lex.data[(lex.p)] {
 		case 61:
-			goto tr651
+			goto tr654
 		case 124:
-			goto tr652
+			goto tr655
 		}
 		goto tr232
 	tr138:
-//line scanner/scanner.rl:378
+//line scanner/scanner.rl:380
 		(lex.p) = (lex.te) - 1
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st463
-	tr653:
-//line scanner/scanner.rl:381
+		goto st464
+	tr656:
+//line scanner/scanner.rl:383
 		lex.te = (lex.p) + 1
 		{
 			lex.ungetCnt(1)
@@ -16818,27 +16866,27 @@ func (lex *Lexer) Lex(lval Lval) int {
 				goto st117
 			}
 		}
-		goto st463
-	tr658:
-//line scanner/scanner.rl:378
+		goto st464
+	tr661:
+//line scanner/scanner.rl:380
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st463
-	tr660:
+		goto st464
+	tr663:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:378
+//line scanner/scanner.rl:380
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st463
-	tr664:
-//line scanner/scanner.rl:381
+		goto st464
+	tr667:
+//line scanner/scanner.rl:383
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -16847,23 +16895,23 @@ func (lex *Lexer) Lex(lval Lval) int {
 				goto st117
 			}
 		}
-		goto st463
-	tr665:
-//line scanner/scanner.rl:379
+		goto st464
+	tr668:
+//line scanner/scanner.rl:381
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
 			tok = T_OBJECT_OPERATOR
 			{
 				(lex.p)++
-				lex.cs = 463
+				lex.cs = 464
 				goto _out
 			}
 		}
-		goto st463
-	tr666:
-		lex.cs = 463
-//line scanner/scanner.rl:380
+		goto st464
+	tr669:
+		lex.cs = 464
+//line scanner/scanner.rl:382
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -16876,89 +16924,59 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto _again
-	st463:
+	st464:
 //line NONE:1
 		lex.ts = 0
 
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof463
+			goto _test_eof464
 		}
-	st_case_463:
+	st_case_464:
 //line NONE:1
 		lex.ts = (lex.p)
 
-//line scanner/scanner.go:15734
+//line scanner/scanner.go:15767
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr139
 		case 13:
-			goto st466
-		case 32:
-			goto tr654
-		case 45:
 			goto st467
+		case 32:
+			goto tr657
+		case 45:
+			goto st468
 		case 96:
-			goto tr653
+			goto tr656
 		}
 		switch {
 		case lex.data[(lex.p)] < 14:
 			switch {
 			case lex.data[(lex.p)] > 8:
 				if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-					goto tr654
+					goto tr657
 				}
 			default:
-				goto tr653
+				goto tr656
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr653
+					goto tr656
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr653
+				goto tr656
 			}
 		default:
-			goto tr653
+			goto tr656
 		}
-		goto st468
-	tr654:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-		goto st464
-	tr661:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:66
-		lex.NewLines.Append(lex.p)
-		goto st464
-	st464:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof464
-		}
-	st_case_464:
-//line scanner/scanner.go:15787
-		switch lex.data[(lex.p)] {
-		case 10:
-			goto tr139
-		case 13:
-			goto st98
-		case 32:
-			goto tr654
-		}
-		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-			goto tr654
-		}
-		goto tr658
-	tr139:
+		goto st469
+	tr657:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 		goto st465
-	tr662:
+	tr664:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
@@ -16970,20 +16988,50 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof465
 		}
 	st_case_465:
-//line scanner/scanner.go:15817
+//line scanner/scanner.go:15820
 		switch lex.data[(lex.p)] {
 		case 10:
-			goto tr662
+			goto tr139
 		case 13:
-			goto tr663
+			goto st98
 		case 32:
-			goto tr661
+			goto tr657
 		}
 		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-			goto tr661
+			goto tr657
 		}
-		goto tr660
-	tr663:
+		goto tr661
+	tr139:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+		goto st466
+	tr665:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:66
+		lex.NewLines.Append(lex.p)
+		goto st466
+	st466:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof466
+		}
+	st_case_466:
+//line scanner/scanner.go:15850
+		switch lex.data[(lex.p)] {
+		case 10:
+			goto tr665
+		case 13:
+			goto tr666
+		case 32:
+			goto tr664
+		}
+		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
+			goto tr664
+		}
+		goto tr663
+	tr666:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
 		goto st98
@@ -16992,57 +17040,57 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof98
 		}
 	st_case_98:
-//line scanner/scanner.go:15839
+//line scanner/scanner.go:15872
 		if lex.data[(lex.p)] == 10 {
 			goto tr139
 		}
 		goto tr138
-	st466:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof466
-		}
-	st_case_466:
-		if lex.data[(lex.p)] == 10 {
-			goto tr139
-		}
-		goto tr664
 	st467:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof467
 		}
 	st_case_467:
-		if lex.data[(lex.p)] == 62 {
-			goto tr665
+		if lex.data[(lex.p)] == 10 {
+			goto tr139
 		}
-		goto tr664
+		goto tr667
 	st468:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof468
 		}
 	st_case_468:
+		if lex.data[(lex.p)] == 62 {
+			goto tr668
+		}
+		goto tr667
+	st469:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof469
+		}
+	st_case_469:
 		if lex.data[(lex.p)] == 96 {
-			goto tr666
+			goto tr669
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr666
+				goto tr669
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr666
+					goto tr669
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr666
+				goto tr669
 			}
 		default:
-			goto tr666
+			goto tr669
 		}
-		goto st468
-	tr669:
-		lex.cs = 469
+		goto st469
+	tr672:
+		lex.cs = 470
 //line NONE:1
 		switch lex.act {
 		case 0:
@@ -17051,13 +17099,13 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto st0
 				}
 			}
-		case 142:
+		case 144:
 			{
 				(lex.p) = (lex.te) - 1
 
 				lex.setTokenPosition(token)
 				tok = T_ENCAPSED_AND_WHITESPACE
-				lex.cs = 490
+				lex.cs = 491
 				{
 					(lex.p)++
 					goto _out
@@ -17066,24 +17114,24 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 
 		goto _again
-	tr670:
-		lex.cs = 469
+	tr673:
+		lex.cs = 470
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:385
+//line scanner/scanner.rl:387
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			lex.setTokenPosition(token)
 			tok = T_ENCAPSED_AND_WHITESPACE
-			lex.cs = 490
+			lex.cs = 491
 			{
 				(lex.p)++
 				goto _out
 			}
 		}
 		goto _again
-	st469:
+	st470:
 //line NONE:1
 		lex.ts = 0
 
@@ -17091,13 +17139,13 @@ func (lex *Lexer) Lex(lval Lval) int {
 		lex.act = 0
 
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof469
+			goto _test_eof470
 		}
-	st_case_469:
+	st_case_470:
 //line NONE:1
 		lex.ts = (lex.p)
 
-//line scanner/scanner.go:15933
+//line scanner/scanner.go:15966
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -17137,93 +17185,38 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		if _widec == 1034 {
-			goto st471
+			goto st472
 		}
 		if 1024 <= _widec && _widec <= 1279 {
-			goto tr667
+			goto tr670
 		}
 		goto st0
 	st_case_0:
 	st0:
 		lex.cs = 0
 		goto _out
-	tr667:
+	tr670:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:385
-		lex.act = 142
-		goto st470
-	tr671:
+//line scanner/scanner.rl:387
+		lex.act = 144
+		goto st471
+	tr674:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:385
-		lex.act = 142
-		goto st470
-	st470:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof470
-		}
-	st_case_470:
-//line scanner/scanner.go:16004
-		_widec = int16(lex.data[(lex.p)])
-		switch {
-		case lex.data[(lex.p)] < 11:
-			switch {
-			case lex.data[(lex.p)] > 9:
-				if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 {
-					_widec = 768 + (int16(lex.data[(lex.p)]) - 0)
-					if lex.isNotHeredocEnd(lex.p) {
-						_widec += 256
-					}
-				}
-			default:
-				_widec = 768 + (int16(lex.data[(lex.p)]) - 0)
-				if lex.isNotHeredocEnd(lex.p) {
-					_widec += 256
-				}
-			}
-		case lex.data[(lex.p)] > 12:
-			switch {
-			case lex.data[(lex.p)] > 13:
-				if 14 <= lex.data[(lex.p)] {
-					_widec = 768 + (int16(lex.data[(lex.p)]) - 0)
-					if lex.isNotHeredocEnd(lex.p) {
-						_widec += 256
-					}
-				}
-			case lex.data[(lex.p)] >= 13:
-				_widec = 768 + (int16(lex.data[(lex.p)]) - 0)
-				if lex.isNotHeredocEnd(lex.p) {
-					_widec += 256
-				}
-			}
-		default:
-			_widec = 768 + (int16(lex.data[(lex.p)]) - 0)
-			if lex.isNotHeredocEnd(lex.p) {
-				_widec += 256
-			}
-		}
-		if _widec == 1034 {
-			goto st471
-		}
-		if 1024 <= _widec && _widec <= 1279 {
-			goto tr667
-		}
-		goto tr669
-	tr672:
-//line scanner/scanner.rl:66
-		lex.NewLines.Append(lex.p)
+//line scanner/scanner.rl:387
+		lex.act = 144
 		goto st471
 	st471:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof471
 		}
 	st_case_471:
-//line scanner/scanner.go:16059
+//line scanner/scanner.go:16037
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -17263,25 +17256,80 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		if _widec == 1034 {
-			goto tr672
+			goto st472
 		}
 		if 1024 <= _widec && _widec <= 1279 {
-			goto tr671
+			goto tr670
 		}
-		goto tr670
+		goto tr672
+	tr675:
+//line scanner/scanner.rl:66
+		lex.NewLines.Append(lex.p)
+		goto st472
+	st472:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof472
+		}
+	st_case_472:
+//line scanner/scanner.go:16092
+		_widec = int16(lex.data[(lex.p)])
+		switch {
+		case lex.data[(lex.p)] < 11:
+			switch {
+			case lex.data[(lex.p)] > 9:
+				if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 {
+					_widec = 768 + (int16(lex.data[(lex.p)]) - 0)
+					if lex.isNotHeredocEnd(lex.p) {
+						_widec += 256
+					}
+				}
+			default:
+				_widec = 768 + (int16(lex.data[(lex.p)]) - 0)
+				if lex.isNotHeredocEnd(lex.p) {
+					_widec += 256
+				}
+			}
+		case lex.data[(lex.p)] > 12:
+			switch {
+			case lex.data[(lex.p)] > 13:
+				if 14 <= lex.data[(lex.p)] {
+					_widec = 768 + (int16(lex.data[(lex.p)]) - 0)
+					if lex.isNotHeredocEnd(lex.p) {
+						_widec += 256
+					}
+				}
+			case lex.data[(lex.p)] >= 13:
+				_widec = 768 + (int16(lex.data[(lex.p)]) - 0)
+				if lex.isNotHeredocEnd(lex.p) {
+					_widec += 256
+				}
+			}
+		default:
+			_widec = 768 + (int16(lex.data[(lex.p)]) - 0)
+			if lex.isNotHeredocEnd(lex.p) {
+				_widec += 256
+			}
+		}
+		if _widec == 1034 {
+			goto tr675
+		}
+		if 1024 <= _widec && _widec <= 1279 {
+			goto tr674
+		}
+		goto tr673
 	tr140:
-//line scanner/scanner.rl:394
+//line scanner/scanner.rl:396
 		lex.te = (lex.p) + 1
 		{
 			lex.ungetCnt(1)
 			lex.setTokenPosition(token)
 			tok = T_CURLY_OPEN
-			lex.call(472, 117)
+			lex.call(473, 117)
 			goto _out
 		}
-		goto st472
-	tr679:
-//line scanner/scanner.rl:396
+		goto st473
+	tr682:
+//line scanner/scanner.rl:398
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -17289,45 +17337,45 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				lex.growCallStack()
 				{
-					lex.stack[lex.top] = 472
+					lex.stack[lex.top] = 473
 					lex.top++
-					goto st492
+					goto st493
 				}
 			}
 		}
-		goto st472
-	tr680:
-//line scanner/scanner.rl:395
+		goto st473
+	tr683:
+//line scanner/scanner.rl:397
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
 			tok = T_DOLLAR_OPEN_CURLY_BRACES
-			lex.call(472, 507)
+			lex.call(473, 508)
 			goto _out
 		}
-		goto st472
-	tr681:
-		lex.cs = 472
+		goto st473
+	tr684:
+		lex.cs = 473
 //line NONE:1
 		switch lex.act {
-		case 143:
+		case 145:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.ungetCnt(1)
 				lex.setTokenPosition(token)
 				tok = T_CURLY_OPEN
-				lex.call(472, 117)
+				lex.call(473, 117)
 				goto _out
 			}
-		case 144:
+		case 146:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
 				tok = T_DOLLAR_OPEN_CURLY_BRACES
-				lex.call(472, 507)
+				lex.call(473, 508)
 				goto _out
 			}
-		case 146:
+		case 148:
 			{
 				(lex.p) = (lex.te) - 1
 
@@ -17335,7 +17383,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 				tok = T_ENCAPSED_AND_WHITESPACE
 
 				if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' {
-					lex.cs = 490
+					lex.cs = 491
 				}
 				{
 					(lex.p)++
@@ -17345,11 +17393,11 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 
 		goto _again
-	tr682:
-		lex.cs = 472
+	tr685:
+		lex.cs = 473
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:397
+//line scanner/scanner.rl:399
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -17357,7 +17405,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_ENCAPSED_AND_WHITESPACE
 
 			if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' {
-				lex.cs = 490
+				lex.cs = 491
 			}
 			{
 				(lex.p)++
@@ -17365,9 +17413,9 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto _again
-	tr686:
-		lex.cs = 472
-//line scanner/scanner.rl:397
+	tr689:
+		lex.cs = 473
+//line scanner/scanner.rl:399
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -17375,7 +17423,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_ENCAPSED_AND_WHITESPACE
 
 			if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' {
-				lex.cs = 490
+				lex.cs = 491
 			}
 			{
 				(lex.p)++
@@ -17383,18 +17431,18 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto _again
-	st472:
+	st473:
 //line NONE:1
 		lex.ts = 0
 
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof472
+			goto _test_eof473
 		}
-	st_case_472:
+	st_case_473:
 //line NONE:1
 		lex.ts = (lex.p)
 
-//line scanner/scanner.go:16188
+//line scanner/scanner.go:16221
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -17435,29 +17483,29 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		switch _widec {
 		case 1316:
-			goto st473
+			goto st474
 		case 1403:
 			goto st99
 		case 1546:
-			goto st475
-		case 1572:
 			goto st476
-		case 1659:
+		case 1572:
 			goto st477
+		case 1659:
+			goto st478
 		}
 		if 1536 <= _widec && _widec <= 1791 {
-			goto tr675
+			goto tr678
 		}
 		goto st0
-	st473:
+	st474:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof473
+			goto _test_eof474
 		}
-	st_case_473:
+	st_case_474:
 		if lex.data[(lex.p)] == 123 {
-			goto tr680
+			goto tr683
 		}
-		goto tr679
+		goto tr682
 	st99:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof99
@@ -17467,97 +17515,42 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto tr140
 		}
 		goto st0
-	tr675:
+	tr678:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:397
-		lex.act = 146
-		goto st474
-	tr683:
+//line scanner/scanner.rl:399
+		lex.act = 148
+		goto st475
+	tr686:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
+//line scanner/scanner.rl:399
+		lex.act = 148
+		goto st475
+	tr688:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
 //line scanner/scanner.rl:397
 		lex.act = 146
-		goto st474
-	tr685:
+		goto st475
+	tr690:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:395
-		lex.act = 144
-		goto st474
-	tr687:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:394
-		lex.act = 143
-		goto st474
-	st474:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof474
-		}
-	st_case_474:
-//line scanner/scanner.go:16296
-		_widec = int16(lex.data[(lex.p)])
-		switch {
-		case lex.data[(lex.p)] < 11:
-			switch {
-			case lex.data[(lex.p)] > 9:
-				if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 {
-					_widec = 1280 + (int16(lex.data[(lex.p)]) - 0)
-					if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() {
-						_widec += 256
-					}
-				}
-			default:
-				_widec = 1280 + (int16(lex.data[(lex.p)]) - 0)
-				if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() {
-					_widec += 256
-				}
-			}
-		case lex.data[(lex.p)] > 12:
-			switch {
-			case lex.data[(lex.p)] > 13:
-				if 14 <= lex.data[(lex.p)] {
-					_widec = 1280 + (int16(lex.data[(lex.p)]) - 0)
-					if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() {
-						_widec += 256
-					}
-				}
-			case lex.data[(lex.p)] >= 13:
-				_widec = 1280 + (int16(lex.data[(lex.p)]) - 0)
-				if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() {
-					_widec += 256
-				}
-			}
-		default:
-			_widec = 1280 + (int16(lex.data[(lex.p)]) - 0)
-			if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() {
-				_widec += 256
-			}
-		}
-		if _widec == 1546 {
-			goto st475
-		}
-		if 1536 <= _widec && _widec <= 1791 {
-			goto tr675
-		}
-		goto tr681
-	tr684:
-//line scanner/scanner.rl:66
-		lex.NewLines.Append(lex.p)
+//line scanner/scanner.rl:396
+		lex.act = 145
 		goto st475
 	st475:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof475
 		}
 	st_case_475:
-//line scanner/scanner.go:16351
+//line scanner/scanner.go:16329
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -17597,17 +17590,22 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		if _widec == 1546 {
-			goto tr684
+			goto st476
 		}
 		if 1536 <= _widec && _widec <= 1791 {
-			goto tr683
+			goto tr678
 		}
-		goto tr682
+		goto tr684
+	tr687:
+//line scanner/scanner.rl:66
+		lex.NewLines.Append(lex.p)
+		goto st476
 	st476:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof476
 		}
 	st_case_476:
+//line scanner/scanner.go:16384
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -17646,23 +17644,73 @@ func (lex *Lexer) Lex(lval Lval) int {
 				_widec += 256
 			}
 		}
-		switch _widec {
-		case 1403:
-			goto tr680
-		case 1546:
-			goto st475
-		case 1659:
-			goto tr685
+		if _widec == 1546 {
+			goto tr687
 		}
 		if 1536 <= _widec && _widec <= 1791 {
-			goto tr675
+			goto tr686
 		}
-		goto tr679
+		goto tr685
 	st477:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof477
 		}
 	st_case_477:
+		_widec = int16(lex.data[(lex.p)])
+		switch {
+		case lex.data[(lex.p)] < 11:
+			switch {
+			case lex.data[(lex.p)] > 9:
+				if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 {
+					_widec = 1280 + (int16(lex.data[(lex.p)]) - 0)
+					if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() {
+						_widec += 256
+					}
+				}
+			default:
+				_widec = 1280 + (int16(lex.data[(lex.p)]) - 0)
+				if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() {
+					_widec += 256
+				}
+			}
+		case lex.data[(lex.p)] > 12:
+			switch {
+			case lex.data[(lex.p)] > 13:
+				if 14 <= lex.data[(lex.p)] {
+					_widec = 1280 + (int16(lex.data[(lex.p)]) - 0)
+					if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() {
+						_widec += 256
+					}
+				}
+			case lex.data[(lex.p)] >= 13:
+				_widec = 1280 + (int16(lex.data[(lex.p)]) - 0)
+				if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() {
+					_widec += 256
+				}
+			}
+		default:
+			_widec = 1280 + (int16(lex.data[(lex.p)]) - 0)
+			if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() {
+				_widec += 256
+			}
+		}
+		switch _widec {
+		case 1403:
+			goto tr683
+		case 1546:
+			goto st476
+		case 1659:
+			goto tr688
+		}
+		if 1536 <= _widec && _widec <= 1791 {
+			goto tr678
+		}
+		goto tr682
+	st478:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof478
+		}
+	st_case_478:
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -17705,28 +17753,28 @@ func (lex *Lexer) Lex(lval Lval) int {
 		case 1316:
 			goto tr140
 		case 1546:
-			goto st475
+			goto st476
 		case 1572:
-			goto tr687
+			goto tr690
 		}
 		if 1536 <= _widec && _widec <= 1791 {
-			goto tr675
+			goto tr678
 		}
-		goto tr686
+		goto tr689
 	tr142:
-//line scanner/scanner.rl:409
+//line scanner/scanner.rl:411
 		lex.te = (lex.p) + 1
 		{
 			lex.ungetCnt(1)
 			lex.setTokenPosition(token)
 			tok = T_CURLY_OPEN
-			lex.call(478, 117)
+			lex.call(479, 117)
 			goto _out
 		}
-		goto st478
-	tr689:
-		lex.cs = 478
-//line scanner/scanner.rl:412
+		goto st479
+	tr692:
+		lex.cs = 479
+//line scanner/scanner.rl:414
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -17738,8 +17786,8 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto _again
-	tr696:
-//line scanner/scanner.rl:411
+	tr699:
+//line scanner/scanner.rl:413
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -17747,45 +17795,45 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				lex.growCallStack()
 				{
-					lex.stack[lex.top] = 478
+					lex.stack[lex.top] = 479
 					lex.top++
-					goto st492
+					goto st493
 				}
 			}
 		}
-		goto st478
-	tr697:
-//line scanner/scanner.rl:410
+		goto st479
+	tr700:
+//line scanner/scanner.rl:412
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
 			tok = T_DOLLAR_OPEN_CURLY_BRACES
-			lex.call(478, 507)
+			lex.call(479, 508)
 			goto _out
 		}
-		goto st478
-	tr698:
-		lex.cs = 478
+		goto st479
+	tr701:
+		lex.cs = 479
 //line NONE:1
 		switch lex.act {
-		case 147:
+		case 149:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.ungetCnt(1)
 				lex.setTokenPosition(token)
 				tok = T_CURLY_OPEN
-				lex.call(478, 117)
+				lex.call(479, 117)
 				goto _out
 			}
-		case 148:
+		case 150:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
 				tok = T_DOLLAR_OPEN_CURLY_BRACES
-				lex.call(478, 507)
+				lex.call(479, 508)
 				goto _out
 			}
-		case 150:
+		case 152:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -17796,7 +17844,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 151:
+		case 153:
 			{
 				(lex.p) = (lex.te) - 1
 
@@ -17810,10 +17858,10 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 
 		goto _again
-	tr699:
+	tr702:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:413
+//line scanner/scanner.rl:415
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -17821,13 +17869,13 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_ENCAPSED_AND_WHITESPACE
 			{
 				(lex.p)++
-				lex.cs = 478
+				lex.cs = 479
 				goto _out
 			}
 		}
-		goto st478
-	tr703:
-//line scanner/scanner.rl:413
+		goto st479
+	tr706:
+//line scanner/scanner.rl:415
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -17835,23 +17883,23 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_ENCAPSED_AND_WHITESPACE
 			{
 				(lex.p)++
-				lex.cs = 478
+				lex.cs = 479
 				goto _out
 			}
 		}
-		goto st478
-	st478:
+		goto st479
+	st479:
 //line NONE:1
 		lex.ts = 0
 
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof478
+			goto _test_eof479
 		}
-	st_case_478:
+	st_case_479:
 //line NONE:1
 		lex.ts = (lex.p)
 
-//line scanner/scanner.go:16585
+//line scanner/scanner.go:16618
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -17892,33 +17940,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		switch _widec {
 		case 1828:
-			goto st479
+			goto st480
 		case 1888:
-			goto tr689
+			goto tr692
 		case 1915:
 			goto st100
 		case 2058:
-			goto st481
-		case 2084:
 			goto st482
-		case 2144:
-			goto tr694
-		case 2171:
+		case 2084:
 			goto st483
+		case 2144:
+			goto tr697
+		case 2171:
+			goto st484
 		}
 		if 2048 <= _widec && _widec <= 2303 {
-			goto tr691
+			goto tr694
 		}
 		goto st0
-	st479:
+	st480:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof479
+			goto _test_eof480
 		}
-	st_case_479:
+	st_case_480:
 		if lex.data[(lex.p)] == 123 {
-			goto tr697
+			goto tr700
 		}
-		goto tr696
+		goto tr699
 	st100:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof100
@@ -17928,104 +17976,49 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto tr142
 		}
 		goto st0
-	tr691:
+	tr694:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:413
-		lex.act = 151
-		goto st480
-	tr694:
+//line scanner/scanner.rl:415
+		lex.act = 153
+		goto st481
+	tr697:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:414
+		lex.act = 152
+		goto st481
+	tr703:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:66
+		lex.NewLines.Append(lex.p)
+//line scanner/scanner.rl:415
+		lex.act = 153
+		goto st481
+	tr705:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:412
 		lex.act = 150
-		goto st480
-	tr700:
+		goto st481
+	tr707:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:66
-		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:413
-		lex.act = 151
-		goto st480
-	tr702:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:410
-		lex.act = 148
-		goto st480
-	tr704:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:409
-		lex.act = 147
-		goto st480
-	st480:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof480
-		}
-	st_case_480:
-//line scanner/scanner.go:16704
-		_widec = int16(lex.data[(lex.p)])
-		switch {
-		case lex.data[(lex.p)] < 11:
-			switch {
-			case lex.data[(lex.p)] > 9:
-				if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 {
-					_widec = 1792 + (int16(lex.data[(lex.p)]) - 0)
-					if lex.isNotStringEnd('`') && lex.isNotStringVar() {
-						_widec += 256
-					}
-				}
-			default:
-				_widec = 1792 + (int16(lex.data[(lex.p)]) - 0)
-				if lex.isNotStringEnd('`') && lex.isNotStringVar() {
-					_widec += 256
-				}
-			}
-		case lex.data[(lex.p)] > 12:
-			switch {
-			case lex.data[(lex.p)] > 13:
-				if 14 <= lex.data[(lex.p)] {
-					_widec = 1792 + (int16(lex.data[(lex.p)]) - 0)
-					if lex.isNotStringEnd('`') && lex.isNotStringVar() {
-						_widec += 256
-					}
-				}
-			case lex.data[(lex.p)] >= 13:
-				_widec = 1792 + (int16(lex.data[(lex.p)]) - 0)
-				if lex.isNotStringEnd('`') && lex.isNotStringVar() {
-					_widec += 256
-				}
-			}
-		default:
-			_widec = 1792 + (int16(lex.data[(lex.p)]) - 0)
-			if lex.isNotStringEnd('`') && lex.isNotStringVar() {
-				_widec += 256
-			}
-		}
-		if _widec == 2058 {
-			goto st481
-		}
-		if 2048 <= _widec && _widec <= 2303 {
-			goto tr691
-		}
-		goto tr698
-	tr701:
-//line scanner/scanner.rl:66
-		lex.NewLines.Append(lex.p)
+//line scanner/scanner.rl:411
+		lex.act = 149
 		goto st481
 	st481:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof481
 		}
 	st_case_481:
-//line scanner/scanner.go:16759
+//line scanner/scanner.go:16737
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -18065,17 +18058,22 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		if _widec == 2058 {
-			goto tr701
+			goto st482
 		}
 		if 2048 <= _widec && _widec <= 2303 {
-			goto tr700
+			goto tr694
 		}
-		goto tr699
+		goto tr701
+	tr704:
+//line scanner/scanner.rl:66
+		lex.NewLines.Append(lex.p)
+		goto st482
 	st482:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof482
 		}
 	st_case_482:
+//line scanner/scanner.go:16792
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -18114,23 +18112,73 @@ func (lex *Lexer) Lex(lval Lval) int {
 				_widec += 256
 			}
 		}
-		switch _widec {
-		case 1915:
-			goto tr697
-		case 2058:
-			goto st481
-		case 2171:
-			goto tr702
+		if _widec == 2058 {
+			goto tr704
 		}
 		if 2048 <= _widec && _widec <= 2303 {
-			goto tr691
+			goto tr703
 		}
-		goto tr696
+		goto tr702
 	st483:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof483
 		}
 	st_case_483:
+		_widec = int16(lex.data[(lex.p)])
+		switch {
+		case lex.data[(lex.p)] < 11:
+			switch {
+			case lex.data[(lex.p)] > 9:
+				if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 {
+					_widec = 1792 + (int16(lex.data[(lex.p)]) - 0)
+					if lex.isNotStringEnd('`') && lex.isNotStringVar() {
+						_widec += 256
+					}
+				}
+			default:
+				_widec = 1792 + (int16(lex.data[(lex.p)]) - 0)
+				if lex.isNotStringEnd('`') && lex.isNotStringVar() {
+					_widec += 256
+				}
+			}
+		case lex.data[(lex.p)] > 12:
+			switch {
+			case lex.data[(lex.p)] > 13:
+				if 14 <= lex.data[(lex.p)] {
+					_widec = 1792 + (int16(lex.data[(lex.p)]) - 0)
+					if lex.isNotStringEnd('`') && lex.isNotStringVar() {
+						_widec += 256
+					}
+				}
+			case lex.data[(lex.p)] >= 13:
+				_widec = 1792 + (int16(lex.data[(lex.p)]) - 0)
+				if lex.isNotStringEnd('`') && lex.isNotStringVar() {
+					_widec += 256
+				}
+			}
+		default:
+			_widec = 1792 + (int16(lex.data[(lex.p)]) - 0)
+			if lex.isNotStringEnd('`') && lex.isNotStringVar() {
+				_widec += 256
+			}
+		}
+		switch _widec {
+		case 1915:
+			goto tr700
+		case 2058:
+			goto st482
+		case 2171:
+			goto tr705
+		}
+		if 2048 <= _widec && _widec <= 2303 {
+			goto tr694
+		}
+		goto tr699
+	st484:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof484
+		}
+	st_case_484:
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -18173,28 +18221,28 @@ func (lex *Lexer) Lex(lval Lval) int {
 		case 1828:
 			goto tr142
 		case 2058:
-			goto st481
+			goto st482
 		case 2084:
-			goto tr704
+			goto tr707
 		}
 		if 2048 <= _widec && _widec <= 2303 {
-			goto tr691
+			goto tr694
 		}
-		goto tr703
+		goto tr706
 	tr143:
-//line scanner/scanner.rl:421
+//line scanner/scanner.rl:423
 		lex.te = (lex.p) + 1
 		{
 			lex.ungetCnt(1)
 			lex.setTokenPosition(token)
 			tok = T_CURLY_OPEN
-			lex.call(484, 117)
+			lex.call(485, 117)
 			goto _out
 		}
-		goto st484
-	tr705:
-		lex.cs = 484
-//line scanner/scanner.rl:424
+		goto st485
+	tr708:
+		lex.cs = 485
+//line scanner/scanner.rl:426
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -18206,8 +18254,8 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto _again
-	tr713:
-//line scanner/scanner.rl:423
+	tr716:
+//line scanner/scanner.rl:425
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -18215,45 +18263,45 @@ func (lex *Lexer) Lex(lval Lval) int {
 			{
 				lex.growCallStack()
 				{
-					lex.stack[lex.top] = 484
+					lex.stack[lex.top] = 485
 					lex.top++
-					goto st492
+					goto st493
 				}
 			}
 		}
-		goto st484
-	tr714:
-//line scanner/scanner.rl:422
+		goto st485
+	tr717:
+//line scanner/scanner.rl:424
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
 			tok = T_DOLLAR_OPEN_CURLY_BRACES
-			lex.call(484, 507)
+			lex.call(485, 508)
 			goto _out
 		}
-		goto st484
-	tr715:
-		lex.cs = 484
+		goto st485
+	tr718:
+		lex.cs = 485
 //line NONE:1
 		switch lex.act {
-		case 152:
+		case 154:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.ungetCnt(1)
 				lex.setTokenPosition(token)
 				tok = T_CURLY_OPEN
-				lex.call(484, 117)
+				lex.call(485, 117)
 				goto _out
 			}
-		case 153:
+		case 155:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
 				tok = T_DOLLAR_OPEN_CURLY_BRACES
-				lex.call(484, 507)
+				lex.call(485, 508)
 				goto _out
 			}
-		case 155:
+		case 157:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.setTokenPosition(token)
@@ -18264,7 +18312,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto _out
 				}
 			}
-		case 156:
+		case 158:
 			{
 				(lex.p) = (lex.te) - 1
 
@@ -18278,10 +18326,10 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 
 		goto _again
-	tr716:
+	tr719:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:425
+//line scanner/scanner.rl:427
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -18289,13 +18337,13 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_ENCAPSED_AND_WHITESPACE
 			{
 				(lex.p)++
-				lex.cs = 484
+				lex.cs = 485
 				goto _out
 			}
 		}
-		goto st484
-	tr720:
-//line scanner/scanner.rl:425
+		goto st485
+	tr723:
+//line scanner/scanner.rl:427
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -18303,23 +18351,23 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_ENCAPSED_AND_WHITESPACE
 			{
 				(lex.p)++
-				lex.cs = 484
+				lex.cs = 485
 				goto _out
 			}
 		}
-		goto st484
-	st484:
+		goto st485
+	st485:
 //line NONE:1
 		lex.ts = 0
 
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof484
+			goto _test_eof485
 		}
-	st_case_484:
+	st_case_485:
 //line NONE:1
 		lex.ts = (lex.p)
 
-//line scanner/scanner.go:16993
+//line scanner/scanner.go:17026
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -18360,33 +18408,33 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		switch _widec {
 		case 2338:
-			goto tr705
+			goto tr708
 		case 2340:
-			goto st485
+			goto st486
 		case 2427:
 			goto st101
 		case 2570:
-			goto st487
-		case 2594:
-			goto tr710
-		case 2596:
 			goto st488
-		case 2683:
+		case 2594:
+			goto tr713
+		case 2596:
 			goto st489
+		case 2683:
+			goto st490
 		}
 		if 2560 <= _widec && _widec <= 2815 {
-			goto tr708
+			goto tr711
 		}
 		goto st0
-	st485:
+	st486:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof485
+			goto _test_eof486
 		}
-	st_case_485:
+	st_case_486:
 		if lex.data[(lex.p)] == 123 {
-			goto tr714
+			goto tr717
 		}
-		goto tr713
+		goto tr716
 	st101:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof101
@@ -18396,104 +18444,49 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto tr143
 		}
 		goto st0
-	tr708:
+	tr711:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:425
-		lex.act = 156
-		goto st486
-	tr710:
+//line scanner/scanner.rl:427
+		lex.act = 158
+		goto st487
+	tr713:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:426
+		lex.act = 157
+		goto st487
+	tr720:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:66
+		lex.NewLines.Append(lex.p)
+//line scanner/scanner.rl:427
+		lex.act = 158
+		goto st487
+	tr722:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 //line scanner/scanner.rl:424
 		lex.act = 155
-		goto st486
-	tr717:
+		goto st487
+	tr724:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-//line scanner/scanner.rl:66
-		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:425
-		lex.act = 156
-		goto st486
-	tr719:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:422
-		lex.act = 153
-		goto st486
-	tr721:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:421
-		lex.act = 152
-		goto st486
-	st486:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof486
-		}
-	st_case_486:
-//line scanner/scanner.go:17112
-		_widec = int16(lex.data[(lex.p)])
-		switch {
-		case lex.data[(lex.p)] < 11:
-			switch {
-			case lex.data[(lex.p)] > 9:
-				if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 {
-					_widec = 2304 + (int16(lex.data[(lex.p)]) - 0)
-					if lex.isNotStringEnd('"') && lex.isNotStringVar() {
-						_widec += 256
-					}
-				}
-			default:
-				_widec = 2304 + (int16(lex.data[(lex.p)]) - 0)
-				if lex.isNotStringEnd('"') && lex.isNotStringVar() {
-					_widec += 256
-				}
-			}
-		case lex.data[(lex.p)] > 12:
-			switch {
-			case lex.data[(lex.p)] > 13:
-				if 14 <= lex.data[(lex.p)] {
-					_widec = 2304 + (int16(lex.data[(lex.p)]) - 0)
-					if lex.isNotStringEnd('"') && lex.isNotStringVar() {
-						_widec += 256
-					}
-				}
-			case lex.data[(lex.p)] >= 13:
-				_widec = 2304 + (int16(lex.data[(lex.p)]) - 0)
-				if lex.isNotStringEnd('"') && lex.isNotStringVar() {
-					_widec += 256
-				}
-			}
-		default:
-			_widec = 2304 + (int16(lex.data[(lex.p)]) - 0)
-			if lex.isNotStringEnd('"') && lex.isNotStringVar() {
-				_widec += 256
-			}
-		}
-		if _widec == 2570 {
-			goto st487
-		}
-		if 2560 <= _widec && _widec <= 2815 {
-			goto tr708
-		}
-		goto tr715
-	tr718:
-//line scanner/scanner.rl:66
-		lex.NewLines.Append(lex.p)
+//line scanner/scanner.rl:423
+		lex.act = 154
 		goto st487
 	st487:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof487
 		}
 	st_case_487:
-//line scanner/scanner.go:17167
+//line scanner/scanner.go:17145
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -18533,17 +18526,22 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		if _widec == 2570 {
-			goto tr718
+			goto st488
 		}
 		if 2560 <= _widec && _widec <= 2815 {
-			goto tr717
+			goto tr711
 		}
-		goto tr716
+		goto tr718
+	tr721:
+//line scanner/scanner.rl:66
+		lex.NewLines.Append(lex.p)
+		goto st488
 	st488:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof488
 		}
 	st_case_488:
+//line scanner/scanner.go:17200
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -18582,23 +18580,73 @@ func (lex *Lexer) Lex(lval Lval) int {
 				_widec += 256
 			}
 		}
-		switch _widec {
-		case 2427:
-			goto tr714
-		case 2570:
-			goto st487
-		case 2683:
-			goto tr719
+		if _widec == 2570 {
+			goto tr721
 		}
 		if 2560 <= _widec && _widec <= 2815 {
-			goto tr708
+			goto tr720
 		}
-		goto tr713
+		goto tr719
 	st489:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof489
 		}
 	st_case_489:
+		_widec = int16(lex.data[(lex.p)])
+		switch {
+		case lex.data[(lex.p)] < 11:
+			switch {
+			case lex.data[(lex.p)] > 9:
+				if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 {
+					_widec = 2304 + (int16(lex.data[(lex.p)]) - 0)
+					if lex.isNotStringEnd('"') && lex.isNotStringVar() {
+						_widec += 256
+					}
+				}
+			default:
+				_widec = 2304 + (int16(lex.data[(lex.p)]) - 0)
+				if lex.isNotStringEnd('"') && lex.isNotStringVar() {
+					_widec += 256
+				}
+			}
+		case lex.data[(lex.p)] > 12:
+			switch {
+			case lex.data[(lex.p)] > 13:
+				if 14 <= lex.data[(lex.p)] {
+					_widec = 2304 + (int16(lex.data[(lex.p)]) - 0)
+					if lex.isNotStringEnd('"') && lex.isNotStringVar() {
+						_widec += 256
+					}
+				}
+			case lex.data[(lex.p)] >= 13:
+				_widec = 2304 + (int16(lex.data[(lex.p)]) - 0)
+				if lex.isNotStringEnd('"') && lex.isNotStringVar() {
+					_widec += 256
+				}
+			}
+		default:
+			_widec = 2304 + (int16(lex.data[(lex.p)]) - 0)
+			if lex.isNotStringEnd('"') && lex.isNotStringVar() {
+				_widec += 256
+			}
+		}
+		switch _widec {
+		case 2427:
+			goto tr717
+		case 2570:
+			goto st488
+		case 2683:
+			goto tr722
+		}
+		if 2560 <= _widec && _widec <= 2815 {
+			goto tr711
+		}
+		goto tr716
+	st490:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof490
+		}
+	st_case_490:
 		_widec = int16(lex.data[(lex.p)])
 		switch {
 		case lex.data[(lex.p)] < 11:
@@ -18641,17 +18689,17 @@ func (lex *Lexer) Lex(lval Lval) int {
 		case 2340:
 			goto tr143
 		case 2570:
-			goto st487
+			goto st488
 		case 2596:
-			goto tr721
+			goto tr724
 		}
 		if 2560 <= _widec && _widec <= 2815 {
-			goto tr708
+			goto tr711
 		}
-		goto tr720
-	tr723:
-		lex.cs = 490
-//line scanner/scanner.rl:433
+		goto tr723
+	tr726:
+		lex.cs = 491
+//line scanner/scanner.rl:435
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -18664,18 +18712,18 @@ func (lex *Lexer) Lex(lval Lval) int {
 			}
 		}
 		goto _again
-	st490:
+	st491:
 //line NONE:1
 		lex.ts = 0
 
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof490
+			goto _test_eof491
 		}
-	st_case_490:
+	st_case_491:
 //line NONE:1
 		lex.ts = (lex.p)
 
-//line scanner/scanner.go:17346
+//line scanner/scanner.go:17379
 		if lex.data[(lex.p)] == 96 {
 			goto st0
 		}
@@ -18691,35 +18739,35 @@ func (lex *Lexer) Lex(lval Lval) int {
 		default:
 			goto st0
 		}
-		goto st491
-	st491:
+		goto st492
+	st492:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof491
+			goto _test_eof492
 		}
-	st_case_491:
+	st_case_492:
 		if lex.data[(lex.p)] == 96 {
-			goto tr723
+			goto tr726
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr723
+				goto tr726
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr723
+					goto tr726
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr723
+				goto tr726
 			}
 		default:
-			goto tr723
+			goto tr726
 		}
-		goto st491
+		goto st492
 	tr144:
-//line scanner/scanner.rl:452
+//line scanner/scanner.rl:454
 		(lex.p) = (lex.te) - 1
 		{
 			lex.ungetCnt(1)
@@ -18729,9 +18777,9 @@ func (lex *Lexer) Lex(lval Lval) int {
 				goto _again
 			}
 		}
-		goto st492
+		goto st493
 	tr145:
-//line scanner/scanner.rl:449
+//line scanner/scanner.rl:451
 		lex.te = (lex.p) + 1
 		{
 			lex.ungetCnt(1)
@@ -18739,13 +18787,13 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_OBJECT_OPERATOR
 			{
 				(lex.p)++
-				lex.cs = 492
+				lex.cs = 493
 				goto _out
 			}
 		}
-		goto st492
-	tr724:
-//line scanner/scanner.rl:452
+		goto st493
+	tr727:
+//line scanner/scanner.rl:454
 		lex.te = (lex.p) + 1
 		{
 			lex.ungetCnt(1)
@@ -18755,19 +18803,19 @@ func (lex *Lexer) Lex(lval Lval) int {
 				goto _again
 			}
 		}
-		goto st492
-	tr728:
-//line scanner/scanner.rl:451
+		goto st493
+	tr731:
+//line scanner/scanner.rl:453
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
 			tok = TokenID(int('['))
-			lex.call(492, 497)
+			lex.call(493, 498)
 			goto _out
 		}
-		goto st492
-	tr729:
-//line scanner/scanner.rl:452
+		goto st493
+	tr732:
+//line scanner/scanner.rl:454
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -18778,9 +18826,9 @@ func (lex *Lexer) Lex(lval Lval) int {
 				goto _again
 			}
 		}
-		goto st492
-	tr731:
-//line scanner/scanner.rl:448
+		goto st493
+	tr734:
+//line scanner/scanner.rl:450
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -18788,13 +18836,13 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_VARIABLE
 			{
 				(lex.p)++
-				lex.cs = 492
+				lex.cs = 493
 				goto _out
 			}
 		}
-		goto st492
-	tr733:
-//line scanner/scanner.rl:450
+		goto st493
+	tr736:
+//line scanner/scanner.rl:452
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -18802,108 +18850,108 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_STRING
 			{
 				(lex.p)++
-				lex.cs = 492
+				lex.cs = 493
 				goto _out
 			}
 		}
-		goto st492
-	st492:
+		goto st493
+	st493:
 //line NONE:1
 		lex.ts = 0
 
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof492
+			goto _test_eof493
 		}
-	st_case_492:
+	st_case_493:
 //line NONE:1
 		lex.ts = (lex.p)
 
-//line scanner/scanner.go:17438
+//line scanner/scanner.go:17471
 		switch lex.data[(lex.p)] {
 		case 36:
-			goto st493
+			goto st494
 		case 45:
-			goto tr726
+			goto tr729
 		case 91:
-			goto tr728
+			goto tr731
 		case 96:
-			goto tr724
+			goto tr727
 		}
 		switch {
 		case lex.data[(lex.p)] < 92:
 			if lex.data[(lex.p)] <= 64 {
-				goto tr724
+				goto tr727
 			}
 		case lex.data[(lex.p)] > 94:
 			if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-				goto tr724
+				goto tr727
 			}
 		default:
-			goto tr724
+			goto tr727
 		}
-		goto st496
-	st493:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof493
-		}
-	st_case_493:
-		if lex.data[(lex.p)] == 96 {
-			goto tr729
-		}
-		switch {
-		case lex.data[(lex.p)] < 91:
-			if lex.data[(lex.p)] <= 64 {
-				goto tr729
-			}
-		case lex.data[(lex.p)] > 94:
-			if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-				goto tr729
-			}
-		default:
-			goto tr729
-		}
-		goto st494
+		goto st497
 	st494:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof494
 		}
 	st_case_494:
 		if lex.data[(lex.p)] == 96 {
-			goto tr731
+			goto tr732
 		}
 		switch {
-		case lex.data[(lex.p)] < 58:
-			if lex.data[(lex.p)] <= 47 {
-				goto tr731
+		case lex.data[(lex.p)] < 91:
+			if lex.data[(lex.p)] <= 64 {
+				goto tr732
 			}
-		case lex.data[(lex.p)] > 64:
-			switch {
-			case lex.data[(lex.p)] > 94:
-				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr731
-				}
-			case lex.data[(lex.p)] >= 91:
-				goto tr731
+		case lex.data[(lex.p)] > 94:
+			if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
+				goto tr732
 			}
 		default:
-			goto tr731
+			goto tr732
 		}
-		goto st494
-	tr726:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
 		goto st495
 	st495:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof495
 		}
 	st_case_495:
-//line scanner/scanner.go:17519
+		if lex.data[(lex.p)] == 96 {
+			goto tr734
+		}
+		switch {
+		case lex.data[(lex.p)] < 58:
+			if lex.data[(lex.p)] <= 47 {
+				goto tr734
+			}
+		case lex.data[(lex.p)] > 64:
+			switch {
+			case lex.data[(lex.p)] > 94:
+				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
+					goto tr734
+				}
+			case lex.data[(lex.p)] >= 91:
+				goto tr734
+			}
+		default:
+			goto tr734
+		}
+		goto st495
+	tr729:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+		goto st496
+	st496:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof496
+		}
+	st_case_496:
+//line scanner/scanner.go:17552
 		if lex.data[(lex.p)] == 62 {
 			goto st102
 		}
-		goto tr729
+		goto tr732
 	st102:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof102
@@ -18925,55 +18973,55 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto tr144
 		}
 		goto tr145
-	st496:
+	st497:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof496
+			goto _test_eof497
 		}
-	st_case_496:
+	st_case_497:
 		if lex.data[(lex.p)] == 96 {
-			goto tr733
+			goto tr736
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
 			if lex.data[(lex.p)] <= 47 {
-				goto tr733
+				goto tr736
 			}
 		case lex.data[(lex.p)] > 64:
 			switch {
 			case lex.data[(lex.p)] > 94:
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr733
+					goto tr736
 				}
 			case lex.data[(lex.p)] >= 91:
-				goto tr733
+				goto tr736
 			}
 		default:
-			goto tr733
+			goto tr736
 		}
-		goto st496
+		goto st497
 	tr146:
-//line scanner/scanner.rl:456
+//line scanner/scanner.rl:458
 		(lex.p) = (lex.te) - 1
 		{
 			lex.setTokenPosition(token)
 			tok = T_NUM_STRING
 			{
 				(lex.p)++
-				lex.cs = 497
+				lex.cs = 498
 				goto _out
 			}
 		}
-		goto st497
-	tr734:
-//line scanner/scanner.rl:462
+		goto st498
+	tr737:
+//line scanner/scanner.rl:464
 		lex.te = (lex.p) + 1
 		{
 			c := lex.data[lex.p]
 			lex.Error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c))
 		}
-		goto st497
-	tr735:
-//line scanner/scanner.rl:459
+		goto st498
+	tr738:
+//line scanner/scanner.rl:461
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -18981,22 +19029,22 @@ func (lex *Lexer) Lex(lval Lval) int {
 			lex.ret(2)
 			goto _out
 		}
-		goto st497
-	tr738:
-//line scanner/scanner.rl:460
+		goto st498
+	tr741:
+//line scanner/scanner.rl:462
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
 			tok = TokenID(int(lex.data[lex.ts]))
 			{
 				(lex.p)++
-				lex.cs = 497
+				lex.cs = 498
 				goto _out
 			}
 		}
-		goto st497
-	tr742:
-//line scanner/scanner.rl:461
+		goto st498
+	tr745:
+//line scanner/scanner.rl:463
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
@@ -19004,11 +19052,11 @@ func (lex *Lexer) Lex(lval Lval) int {
 			lex.ret(2)
 			goto _out
 		}
-		goto st497
-	tr743:
+		goto st498
+	tr746:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:459
+//line scanner/scanner.rl:461
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -19017,18 +19065,18 @@ func (lex *Lexer) Lex(lval Lval) int {
 			lex.ret(2)
 			goto _out
 		}
-		goto st497
-	tr744:
-//line scanner/scanner.rl:462
+		goto st498
+	tr747:
+//line scanner/scanner.rl:464
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			c := lex.data[lex.p]
 			lex.Error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c))
 		}
-		goto st497
-	tr745:
-//line scanner/scanner.rl:460
+		goto st498
+	tr748:
+//line scanner/scanner.rl:462
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -19036,13 +19084,13 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = TokenID(int(lex.data[lex.ts]))
 			{
 				(lex.p)++
-				lex.cs = 497
+				lex.cs = 498
 				goto _out
 			}
 		}
-		goto st497
-	tr747:
-//line scanner/scanner.rl:457
+		goto st498
+	tr750:
+//line scanner/scanner.rl:459
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -19050,13 +19098,13 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_VARIABLE
 			{
 				(lex.p)++
-				lex.cs = 497
+				lex.cs = 498
 				goto _out
 			}
 		}
-		goto st497
-	tr748:
-//line scanner/scanner.rl:456
+		goto st498
+	tr751:
+//line scanner/scanner.rl:458
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -19064,13 +19112,13 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_NUM_STRING
 			{
 				(lex.p)++
-				lex.cs = 497
+				lex.cs = 498
 				goto _out
 			}
 		}
-		goto st497
-	tr752:
-//line scanner/scanner.rl:458
+		goto st498
+	tr755:
+//line scanner/scanner.rl:460
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -19078,64 +19126,64 @@ func (lex *Lexer) Lex(lval Lval) int {
 			tok = T_STRING
 			{
 				(lex.p)++
-				lex.cs = 497
+				lex.cs = 498
 				goto _out
 			}
 		}
-		goto st497
-	st497:
+		goto st498
+	st498:
 //line NONE:1
 		lex.ts = 0
 
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof497
+			goto _test_eof498
 		}
-	st_case_497:
+	st_case_498:
 //line NONE:1
 		lex.ts = (lex.p)
 
-//line scanner/scanner.go:17651
+//line scanner/scanner.go:17684
 		switch lex.data[(lex.p)] {
 		case 10:
-			goto st498
-		case 13:
 			goto st499
-		case 32:
-			goto tr735
-		case 33:
-			goto tr738
-		case 35:
-			goto tr735
-		case 36:
+		case 13:
 			goto st500
+		case 32:
+			goto tr738
+		case 33:
+			goto tr741
+		case 35:
+			goto tr738
+		case 36:
+			goto st501
 		case 39:
-			goto tr735
+			goto tr738
 		case 48:
-			goto tr740
+			goto tr743
 		case 92:
-			goto tr735
+			goto tr738
 		case 93:
-			goto tr742
+			goto tr745
 		case 96:
-			goto tr734
+			goto tr737
 		case 124:
-			goto tr738
+			goto tr741
 		case 126:
-			goto tr738
+			goto tr741
 		}
 		switch {
 		case lex.data[(lex.p)] < 37:
 			switch {
 			case lex.data[(lex.p)] < 9:
 				if lex.data[(lex.p)] <= 8 {
-					goto tr734
+					goto tr737
 				}
 			case lex.data[(lex.p)] > 12:
 				if 14 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 34 {
-					goto tr734
+					goto tr737
 				}
 			default:
-				goto tr735
+				goto tr738
 			}
 		case lex.data[(lex.p)] > 47:
 			switch {
@@ -19147,91 +19195,91 @@ func (lex *Lexer) Lex(lval Lval) int {
 				switch {
 				case lex.data[(lex.p)] > 94:
 					if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-						goto tr734
+						goto tr737
 					}
 				case lex.data[(lex.p)] >= 91:
-					goto tr738
+					goto tr741
 				}
 			default:
-				goto tr738
+				goto tr741
 			}
 		default:
-			goto tr738
+			goto tr741
 		}
-		goto st506
-	st498:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof498
-		}
-	st_case_498:
-		goto tr743
+		goto st507
 	st499:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof499
 		}
 	st_case_499:
-		if lex.data[(lex.p)] == 10 {
-			goto st498
-		}
-		goto tr744
+		goto tr746
 	st500:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof500
 		}
 	st_case_500:
-		if lex.data[(lex.p)] == 96 {
-			goto tr745
+		if lex.data[(lex.p)] == 10 {
+			goto st499
 		}
-		switch {
-		case lex.data[(lex.p)] < 91:
-			if lex.data[(lex.p)] <= 64 {
-				goto tr745
-			}
-		case lex.data[(lex.p)] > 94:
-			if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-				goto tr745
-			}
-		default:
-			goto tr745
-		}
-		goto st501
+		goto tr747
 	st501:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof501
 		}
 	st_case_501:
 		if lex.data[(lex.p)] == 96 {
-			goto tr747
+			goto tr748
 		}
 		switch {
-		case lex.data[(lex.p)] < 58:
-			if lex.data[(lex.p)] <= 47 {
-				goto tr747
+		case lex.data[(lex.p)] < 91:
+			if lex.data[(lex.p)] <= 64 {
+				goto tr748
 			}
-		case lex.data[(lex.p)] > 64:
-			switch {
-			case lex.data[(lex.p)] > 94:
-				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr747
-				}
-			case lex.data[(lex.p)] >= 91:
-				goto tr747
+		case lex.data[(lex.p)] > 94:
+			if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
+				goto tr748
 			}
 		default:
-			goto tr747
+			goto tr748
 		}
-		goto st501
-	tr740:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
 		goto st502
 	st502:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof502
 		}
 	st_case_502:
-//line scanner/scanner.go:17788
+		if lex.data[(lex.p)] == 96 {
+			goto tr750
+		}
+		switch {
+		case lex.data[(lex.p)] < 58:
+			if lex.data[(lex.p)] <= 47 {
+				goto tr750
+			}
+		case lex.data[(lex.p)] > 64:
+			switch {
+			case lex.data[(lex.p)] > 94:
+				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
+					goto tr750
+				}
+			case lex.data[(lex.p)] >= 91:
+				goto tr750
+			}
+		default:
+			goto tr750
+		}
+		goto st502
+	tr743:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+		goto st503
+	st503:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof503
+		}
+	st_case_503:
+//line scanner/scanner.go:17821
 		switch lex.data[(lex.p)] {
 		case 95:
 			goto st103
@@ -19243,25 +19291,25 @@ func (lex *Lexer) Lex(lval Lval) int {
 		if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
 			goto tr147
 		}
-		goto tr748
+		goto tr751
 	tr147:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-		goto st503
-	st503:
+		goto st504
+	st504:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof503
+			goto _test_eof504
 		}
-	st_case_503:
-//line scanner/scanner.go:17811
+	st_case_504:
+//line scanner/scanner.go:17844
 		if lex.data[(lex.p)] == 95 {
 			goto st103
 		}
 		if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
 			goto tr147
 		}
-		goto tr748
+		goto tr751
 	st103:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof103
@@ -19284,20 +19332,20 @@ func (lex *Lexer) Lex(lval Lval) int {
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-		goto st504
-	st504:
+		goto st505
+	st505:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof504
+			goto _test_eof505
 		}
-	st_case_504:
-//line scanner/scanner.go:17847
+	st_case_505:
+//line scanner/scanner.go:17880
 		if lex.data[(lex.p)] == 95 {
 			goto st104
 		}
 		if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 {
 			goto tr148
 		}
-		goto tr748
+		goto tr751
 	st105:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof105
@@ -19320,13 +19368,13 @@ func (lex *Lexer) Lex(lval Lval) int {
 //line NONE:1
 		lex.te = (lex.p) + 1
 
-		goto st505
-	st505:
+		goto st506
+	st506:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof505
+			goto _test_eof506
 		}
-	st_case_505:
-//line scanner/scanner.go:17883
+	st_case_506:
+//line scanner/scanner.go:17916
 		if lex.data[(lex.p)] == 95 {
 			goto st105
 		}
@@ -19342,122 +19390,14 @@ func (lex *Lexer) Lex(lval Lval) int {
 		default:
 			goto tr149
 		}
-		goto tr748
-	st506:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof506
-		}
-	st_case_506:
-		if lex.data[(lex.p)] == 96 {
-			goto tr752
-		}
-		switch {
-		case lex.data[(lex.p)] < 58:
-			if lex.data[(lex.p)] <= 47 {
-				goto tr752
-			}
-		case lex.data[(lex.p)] > 64:
-			switch {
-			case lex.data[(lex.p)] > 94:
-				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-					goto tr752
-				}
-			case lex.data[(lex.p)] >= 91:
-				goto tr752
-			}
-		default:
-			goto tr752
-		}
-		goto st506
-	tr150:
-		lex.cs = 507
-//line scanner/scanner.rl:470
-		(lex.p) = (lex.te) - 1
-		{
-			lex.ungetCnt(1)
-			lex.cs = 117
-		}
-		goto _again
-	tr152:
-		lex.cs = 507
-//line scanner/scanner.rl:469
-		lex.te = (lex.p) + 1
-		{
-			lex.ungetCnt(1)
-			lex.setTokenPosition(token)
-			tok = T_STRING_VARNAME
-			lex.cs = 117
-			{
-				(lex.p)++
-				goto _out
-			}
-		}
-		goto _again
-	tr753:
-		lex.cs = 507
-//line scanner/scanner.rl:470
-		lex.te = (lex.p) + 1
-		{
-			lex.ungetCnt(1)
-			lex.cs = 117
-		}
-		goto _again
-	tr755:
-		lex.cs = 507
-//line scanner/scanner.rl:470
-		lex.te = (lex.p)
-		(lex.p)--
-		{
-			lex.ungetCnt(1)
-			lex.cs = 117
-		}
-		goto _again
+		goto tr751
 	st507:
-//line NONE:1
-		lex.ts = 0
-
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof507
 		}
 	st_case_507:
-//line NONE:1
-		lex.ts = (lex.p)
-
-//line scanner/scanner.go:17962
 		if lex.data[(lex.p)] == 96 {
-			goto tr753
-		}
-		switch {
-		case lex.data[(lex.p)] < 91:
-			if lex.data[(lex.p)] <= 64 {
-				goto tr753
-			}
-		case lex.data[(lex.p)] > 94:
-			if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
-				goto tr753
-			}
-		default:
-			goto tr753
-		}
-		goto tr754
-	tr754:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-		goto st508
-	st508:
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof508
-		}
-	st_case_508:
-//line scanner/scanner.go:17989
-		switch lex.data[(lex.p)] {
-		case 91:
-			goto tr152
-		case 96:
 			goto tr755
-		case 125:
-			goto tr152
 		}
 		switch {
 		case lex.data[(lex.p)] < 58:
@@ -19470,12 +19410,120 @@ func (lex *Lexer) Lex(lval Lval) int {
 				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
 					goto tr755
 				}
-			case lex.data[(lex.p)] >= 92:
+			case lex.data[(lex.p)] >= 91:
 				goto tr755
 			}
 		default:
 			goto tr755
 		}
+		goto st507
+	tr150:
+		lex.cs = 508
+//line scanner/scanner.rl:472
+		(lex.p) = (lex.te) - 1
+		{
+			lex.ungetCnt(1)
+			lex.cs = 117
+		}
+		goto _again
+	tr152:
+		lex.cs = 508
+//line scanner/scanner.rl:471
+		lex.te = (lex.p) + 1
+		{
+			lex.ungetCnt(1)
+			lex.setTokenPosition(token)
+			tok = T_STRING_VARNAME
+			lex.cs = 117
+			{
+				(lex.p)++
+				goto _out
+			}
+		}
+		goto _again
+	tr756:
+		lex.cs = 508
+//line scanner/scanner.rl:472
+		lex.te = (lex.p) + 1
+		{
+			lex.ungetCnt(1)
+			lex.cs = 117
+		}
+		goto _again
+	tr758:
+		lex.cs = 508
+//line scanner/scanner.rl:472
+		lex.te = (lex.p)
+		(lex.p)--
+		{
+			lex.ungetCnt(1)
+			lex.cs = 117
+		}
+		goto _again
+	st508:
+//line NONE:1
+		lex.ts = 0
+
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof508
+		}
+	st_case_508:
+//line NONE:1
+		lex.ts = (lex.p)
+
+//line scanner/scanner.go:17995
+		if lex.data[(lex.p)] == 96 {
+			goto tr756
+		}
+		switch {
+		case lex.data[(lex.p)] < 91:
+			if lex.data[(lex.p)] <= 64 {
+				goto tr756
+			}
+		case lex.data[(lex.p)] > 94:
+			if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
+				goto tr756
+			}
+		default:
+			goto tr756
+		}
+		goto tr757
+	tr757:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+		goto st509
+	st509:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof509
+		}
+	st_case_509:
+//line scanner/scanner.go:18022
+		switch lex.data[(lex.p)] {
+		case 91:
+			goto tr152
+		case 96:
+			goto tr758
+		case 125:
+			goto tr152
+		}
+		switch {
+		case lex.data[(lex.p)] < 58:
+			if lex.data[(lex.p)] <= 47 {
+				goto tr758
+			}
+		case lex.data[(lex.p)] > 64:
+			switch {
+			case lex.data[(lex.p)] > 94:
+				if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
+					goto tr758
+				}
+			case lex.data[(lex.p)] >= 92:
+				goto tr758
+			}
+		default:
+			goto tr758
+		}
 		goto st106
 	st106:
 		if (lex.p)++; (lex.p) == (lex.pe) {
@@ -19509,56 +19557,56 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 		goto st106
 	tr153:
-//line scanner/scanner.rl:474
+//line scanner/scanner.rl:476
 		(lex.p) = (lex.te) - 1
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st509
-	tr756:
-		lex.cs = 509
-//line scanner/scanner.rl:476
+		goto st510
+	tr759:
+		lex.cs = 510
+//line scanner/scanner.rl:478
 		lex.te = (lex.p) + 1
 		{
 			lex.ungetCnt(1)
 			lex.cs = 117
 		}
 		goto _again
-	tr759:
-		lex.cs = 509
-//line scanner/scanner.rl:475
+	tr762:
+		lex.cs = 510
+//line scanner/scanner.rl:477
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
 			tok = TokenID(int('('))
-			lex.cs = 513
+			lex.cs = 514
 			{
 				(lex.p)++
 				goto _out
 			}
 		}
 		goto _again
-	tr760:
-//line scanner/scanner.rl:474
+	tr763:
+//line scanner/scanner.rl:476
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st509
-	tr762:
+		goto st510
+	tr765:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:474
+//line scanner/scanner.rl:476
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st509
-	tr766:
-		lex.cs = 509
-//line scanner/scanner.rl:476
+		goto st510
+	tr769:
+		lex.cs = 510
+//line scanner/scanner.rl:478
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -19566,68 +19614,38 @@ func (lex *Lexer) Lex(lval Lval) int {
 			lex.cs = 117
 		}
 		goto _again
-	st509:
+	st510:
 //line NONE:1
 		lex.ts = 0
 
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof509
-		}
-	st_case_509:
-//line NONE:1
-		lex.ts = (lex.p)
-
-//line scanner/scanner.go:18096
-		switch lex.data[(lex.p)] {
-		case 10:
-			goto tr154
-		case 13:
-			goto st512
-		case 32:
-			goto tr757
-		case 40:
-			goto tr759
-		}
-		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-			goto tr757
-		}
-		goto tr756
-	tr757:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-		goto st510
-	tr763:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:66
-		lex.NewLines.Append(lex.p)
-		goto st510
-	st510:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof510
 		}
 	st_case_510:
-//line scanner/scanner.go:18128
+//line NONE:1
+		lex.ts = (lex.p)
+
+//line scanner/scanner.go:18129
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr154
 		case 13:
-			goto st107
+			goto st513
 		case 32:
-			goto tr757
+			goto tr760
+		case 40:
+			goto tr762
 		}
 		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-			goto tr757
+			goto tr760
 		}
-		goto tr760
-	tr154:
+		goto tr759
+	tr760:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 		goto st511
-	tr764:
+	tr766:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
@@ -19639,20 +19657,50 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof511
 		}
 	st_case_511:
-//line scanner/scanner.go:18158
+//line scanner/scanner.go:18161
 		switch lex.data[(lex.p)] {
 		case 10:
-			goto tr764
+			goto tr154
 		case 13:
-			goto tr765
+			goto st107
 		case 32:
-			goto tr763
+			goto tr760
 		}
 		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-			goto tr763
+			goto tr760
 		}
-		goto tr762
-	tr765:
+		goto tr763
+	tr154:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+		goto st512
+	tr767:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:66
+		lex.NewLines.Append(lex.p)
+		goto st512
+	st512:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof512
+		}
+	st_case_512:
+//line scanner/scanner.go:18191
+		switch lex.data[(lex.p)] {
+		case 10:
+			goto tr767
+		case 13:
+			goto tr768
+		case 32:
+			goto tr766
+		}
+		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
+			goto tr766
+		}
+		goto tr765
+	tr768:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
 		goto st107
@@ -19661,71 +19709,71 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof107
 		}
 	st_case_107:
-//line scanner/scanner.go:18180
+//line scanner/scanner.go:18213
 		if lex.data[(lex.p)] == 10 {
 			goto tr154
 		}
 		goto tr153
-	st512:
+	st513:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof512
+			goto _test_eof513
 		}
-	st_case_512:
+	st_case_513:
 		if lex.data[(lex.p)] == 10 {
 			goto tr154
 		}
-		goto tr766
+		goto tr769
 	tr155:
-//line scanner/scanner.rl:480
+//line scanner/scanner.rl:482
 		(lex.p) = (lex.te) - 1
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st513
-	tr767:
-		lex.cs = 513
-//line scanner/scanner.rl:482
+		goto st514
+	tr770:
+		lex.cs = 514
+//line scanner/scanner.rl:484
 		lex.te = (lex.p) + 1
 		{
 			lex.ungetCnt(1)
 			lex.cs = 117
 		}
 		goto _again
-	tr770:
-		lex.cs = 513
-//line scanner/scanner.rl:481
+	tr773:
+		lex.cs = 514
+//line scanner/scanner.rl:483
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
 			tok = TokenID(int(')'))
-			lex.cs = 517
+			lex.cs = 518
 			{
 				(lex.p)++
 				goto _out
 			}
 		}
 		goto _again
-	tr771:
-//line scanner/scanner.rl:480
+	tr774:
+//line scanner/scanner.rl:482
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st513
-	tr773:
+		goto st514
+	tr776:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:480
+//line scanner/scanner.rl:482
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st513
-	tr777:
-		lex.cs = 513
-//line scanner/scanner.rl:482
+		goto st514
+	tr780:
+		lex.cs = 514
+//line scanner/scanner.rl:484
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -19733,68 +19781,38 @@ func (lex *Lexer) Lex(lval Lval) int {
 			lex.cs = 117
 		}
 		goto _again
-	st513:
+	st514:
 //line NONE:1
 		lex.ts = 0
 
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof513
-		}
-	st_case_513:
-//line NONE:1
-		lex.ts = (lex.p)
-
-//line scanner/scanner.go:18243
-		switch lex.data[(lex.p)] {
-		case 10:
-			goto tr156
-		case 13:
-			goto st516
-		case 32:
-			goto tr768
-		case 41:
-			goto tr770
-		}
-		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-			goto tr768
-		}
-		goto tr767
-	tr768:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-		goto st514
-	tr774:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:66
-		lex.NewLines.Append(lex.p)
-		goto st514
-	st514:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof514
 		}
 	st_case_514:
-//line scanner/scanner.go:18275
+//line NONE:1
+		lex.ts = (lex.p)
+
+//line scanner/scanner.go:18276
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr156
 		case 13:
-			goto st108
+			goto st517
 		case 32:
-			goto tr768
+			goto tr771
+		case 41:
+			goto tr773
 		}
 		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-			goto tr768
+			goto tr771
 		}
-		goto tr771
-	tr156:
+		goto tr770
+	tr771:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 		goto st515
-	tr775:
+	tr777:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
@@ -19806,20 +19824,50 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof515
 		}
 	st_case_515:
-//line scanner/scanner.go:18305
+//line scanner/scanner.go:18308
 		switch lex.data[(lex.p)] {
 		case 10:
-			goto tr775
+			goto tr156
 		case 13:
-			goto tr776
+			goto st108
 		case 32:
-			goto tr774
+			goto tr771
 		}
 		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-			goto tr774
+			goto tr771
 		}
-		goto tr773
-	tr776:
+		goto tr774
+	tr156:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+		goto st516
+	tr778:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:66
+		lex.NewLines.Append(lex.p)
+		goto st516
+	st516:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof516
+		}
+	st_case_516:
+//line scanner/scanner.go:18338
+		switch lex.data[(lex.p)] {
+		case 10:
+			goto tr778
+		case 13:
+			goto tr779
+		case 32:
+			goto tr777
+		}
+		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
+			goto tr777
+		}
+		goto tr776
+	tr779:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
 		goto st108
@@ -19828,71 +19876,71 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof108
 		}
 	st_case_108:
-//line scanner/scanner.go:18327
+//line scanner/scanner.go:18360
 		if lex.data[(lex.p)] == 10 {
 			goto tr156
 		}
 		goto tr155
-	st516:
+	st517:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof516
+			goto _test_eof517
 		}
-	st_case_516:
+	st_case_517:
 		if lex.data[(lex.p)] == 10 {
 			goto tr156
 		}
-		goto tr777
+		goto tr780
 	tr157:
-//line scanner/scanner.rl:486
+//line scanner/scanner.rl:488
 		(lex.p) = (lex.te) - 1
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st517
-	tr778:
-		lex.cs = 517
-//line scanner/scanner.rl:488
+		goto st518
+	tr781:
+		lex.cs = 518
+//line scanner/scanner.rl:490
 		lex.te = (lex.p) + 1
 		{
 			lex.ungetCnt(1)
 			lex.cs = 117
 		}
 		goto _again
-	tr781:
-		lex.cs = 517
-//line scanner/scanner.rl:487
+	tr784:
+		lex.cs = 518
+//line scanner/scanner.rl:489
 		lex.te = (lex.p) + 1
 		{
 			lex.setTokenPosition(token)
 			tok = TokenID(int(';'))
-			lex.cs = 521
+			lex.cs = 522
 			{
 				(lex.p)++
 				goto _out
 			}
 		}
 		goto _again
-	tr782:
-//line scanner/scanner.rl:486
+	tr785:
+//line scanner/scanner.rl:488
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st517
-	tr784:
+		goto st518
+	tr787:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:486
+//line scanner/scanner.rl:488
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)
 		}
-		goto st517
-	tr788:
-		lex.cs = 517
-//line scanner/scanner.rl:488
+		goto st518
+	tr791:
+		lex.cs = 518
+//line scanner/scanner.rl:490
 		lex.te = (lex.p)
 		(lex.p)--
 		{
@@ -19900,68 +19948,38 @@ func (lex *Lexer) Lex(lval Lval) int {
 			lex.cs = 117
 		}
 		goto _again
-	st517:
+	st518:
 //line NONE:1
 		lex.ts = 0
 
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof517
-		}
-	st_case_517:
-//line NONE:1
-		lex.ts = (lex.p)
-
-//line scanner/scanner.go:18390
-		switch lex.data[(lex.p)] {
-		case 10:
-			goto tr158
-		case 13:
-			goto st520
-		case 32:
-			goto tr779
-		case 59:
-			goto tr781
-		}
-		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-			goto tr779
-		}
-		goto tr778
-	tr779:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-		goto st518
-	tr785:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:66
-		lex.NewLines.Append(lex.p)
-		goto st518
-	st518:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof518
 		}
 	st_case_518:
-//line scanner/scanner.go:18422
+//line NONE:1
+		lex.ts = (lex.p)
+
+//line scanner/scanner.go:18423
 		switch lex.data[(lex.p)] {
 		case 10:
 			goto tr158
 		case 13:
-			goto st109
+			goto st521
 		case 32:
-			goto tr779
+			goto tr782
+		case 59:
+			goto tr784
 		}
 		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-			goto tr779
+			goto tr782
 		}
-		goto tr782
-	tr158:
+		goto tr781
+	tr782:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
 		goto st519
-	tr786:
+	tr788:
 //line NONE:1
 		lex.te = (lex.p) + 1
 
@@ -19973,20 +19991,50 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof519
 		}
 	st_case_519:
-//line scanner/scanner.go:18452
+//line scanner/scanner.go:18455
 		switch lex.data[(lex.p)] {
 		case 10:
-			goto tr786
+			goto tr158
 		case 13:
-			goto tr787
+			goto st109
 		case 32:
-			goto tr785
+			goto tr782
 		}
 		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
-			goto tr785
+			goto tr782
 		}
-		goto tr784
-	tr787:
+		goto tr785
+	tr158:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+		goto st520
+	tr789:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:66
+		lex.NewLines.Append(lex.p)
+		goto st520
+	st520:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof520
+		}
+	st_case_520:
+//line scanner/scanner.go:18485
+		switch lex.data[(lex.p)] {
+		case 10:
+			goto tr789
+		case 13:
+			goto tr790
+		case 32:
+			goto tr788
+		}
+		if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
+			goto tr788
+		}
+		goto tr787
+	tr790:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
 		goto st109
@@ -19995,21 +20043,21 @@ func (lex *Lexer) Lex(lval Lval) int {
 			goto _test_eof109
 		}
 	st_case_109:
-//line scanner/scanner.go:18474
+//line scanner/scanner.go:18507
 		if lex.data[(lex.p)] == 10 {
 			goto tr158
 		}
 		goto tr157
-	st520:
+	st521:
 		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof520
+			goto _test_eof521
 		}
-	st_case_520:
+	st_case_521:
 		if lex.data[(lex.p)] == 10 {
 			goto tr158
 		}
-		goto tr788
-	tr791:
+		goto tr791
+	tr794:
 //line NONE:1
 		switch lex.act {
 		case 0:
@@ -20018,83 +20066,83 @@ func (lex *Lexer) Lex(lval Lval) int {
 					goto st0
 				}
 			}
-		case 182:
+		case 184:
 			{
 				(lex.p) = (lex.te) - 1
 				lex.addFreeFloating(freefloating.TokenType, lex.ts, lex.te)
 			}
 		}
 
-		goto st521
-	tr792:
+		goto st522
+	tr795:
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:492
+//line scanner/scanner.rl:494
 		lex.te = (lex.p)
 		(lex.p)--
 		{
 			lex.addFreeFloating(freefloating.TokenType, lex.ts, lex.te)
 		}
-		goto st521
-	st521:
+		goto st522
+	st522:
 //line NONE:1
 		lex.ts = 0
 
 //line NONE:1
 		lex.act = 0
 
-		if (lex.p)++; (lex.p) == (lex.pe) {
-			goto _test_eof521
-		}
-	st_case_521:
-//line NONE:1
-		lex.ts = (lex.p)
-
-//line scanner/scanner.go:18521
-		if lex.data[(lex.p)] == 10 {
-			goto st523
-		}
-		goto tr789
-	tr789:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:492
-		lex.act = 182
-		goto st522
-	tr793:
-//line NONE:1
-		lex.te = (lex.p) + 1
-
-//line scanner/scanner.rl:66
-		lex.NewLines.Append(lex.p)
-//line scanner/scanner.rl:492
-		lex.act = 182
-		goto st522
-	st522:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof522
 		}
 	st_case_522:
-//line scanner/scanner.go:18547
+//line NONE:1
+		lex.ts = (lex.p)
+
+//line scanner/scanner.go:18554
 		if lex.data[(lex.p)] == 10 {
-			goto st523
+			goto st524
 		}
-		goto tr789
-	tr794:
+		goto tr792
+	tr792:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
+//line scanner/scanner.rl:494
+		lex.act = 184
+		goto st523
+	tr796:
+//line NONE:1
+		lex.te = (lex.p) + 1
+
 //line scanner/scanner.rl:66
 		lex.NewLines.Append(lex.p)
+//line scanner/scanner.rl:494
+		lex.act = 184
 		goto st523
 	st523:
 		if (lex.p)++; (lex.p) == (lex.pe) {
 			goto _test_eof523
 		}
 	st_case_523:
-//line scanner/scanner.go:18561
+//line scanner/scanner.go:18580
 		if lex.data[(lex.p)] == 10 {
-			goto tr794
+			goto st524
 		}
-		goto tr793
+		goto tr792
+	tr797:
+//line scanner/scanner.rl:66
+		lex.NewLines.Append(lex.p)
+		goto st524
+	st524:
+		if (lex.p)++; (lex.p) == (lex.pe) {
+			goto _test_eof524
+		}
+	st_case_524:
+//line scanner/scanner.go:18594
+		if lex.data[(lex.p)] == 10 {
+			goto tr797
+		}
+		goto tr796
 	st_out:
 	_test_eof110:
 		lex.cs = 110
@@ -20552,15 +20600,15 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof172:
 		lex.cs = 172
 		goto _test_eof
+	_test_eof173:
+		lex.cs = 173
+		goto _test_eof
 	_test_eof90:
 		lex.cs = 90
 		goto _test_eof
 	_test_eof91:
 		lex.cs = 91
 		goto _test_eof
-	_test_eof173:
-		lex.cs = 173
-		goto _test_eof
 	_test_eof174:
 		lex.cs = 174
 		goto _test_eof
@@ -21218,6 +21266,9 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof392:
 		lex.cs = 392
 		goto _test_eof
+	_test_eof393:
+		lex.cs = 393
+		goto _test_eof
 	_test_eof92:
 		lex.cs = 92
 		goto _test_eof
@@ -21236,9 +21287,6 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof97:
 		lex.cs = 97
 		goto _test_eof
-	_test_eof393:
-		lex.cs = 393
-		goto _test_eof
 	_test_eof394:
 		lex.cs = 394
 		goto _test_eof
@@ -21455,12 +21503,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof465:
 		lex.cs = 465
 		goto _test_eof
-	_test_eof98:
-		lex.cs = 98
-		goto _test_eof
 	_test_eof466:
 		lex.cs = 466
 		goto _test_eof
+	_test_eof98:
+		lex.cs = 98
+		goto _test_eof
 	_test_eof467:
 		lex.cs = 467
 		goto _test_eof
@@ -21482,12 +21530,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof473:
 		lex.cs = 473
 		goto _test_eof
-	_test_eof99:
-		lex.cs = 99
-		goto _test_eof
 	_test_eof474:
 		lex.cs = 474
 		goto _test_eof
+	_test_eof99:
+		lex.cs = 99
+		goto _test_eof
 	_test_eof475:
 		lex.cs = 475
 		goto _test_eof
@@ -21503,12 +21551,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof479:
 		lex.cs = 479
 		goto _test_eof
-	_test_eof100:
-		lex.cs = 100
-		goto _test_eof
 	_test_eof480:
 		lex.cs = 480
 		goto _test_eof
+	_test_eof100:
+		lex.cs = 100
+		goto _test_eof
 	_test_eof481:
 		lex.cs = 481
 		goto _test_eof
@@ -21524,12 +21572,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof485:
 		lex.cs = 485
 		goto _test_eof
-	_test_eof101:
-		lex.cs = 101
-		goto _test_eof
 	_test_eof486:
 		lex.cs = 486
 		goto _test_eof
+	_test_eof101:
+		lex.cs = 101
+		goto _test_eof
 	_test_eof487:
 		lex.cs = 487
 		goto _test_eof
@@ -21557,12 +21605,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof495:
 		lex.cs = 495
 		goto _test_eof
-	_test_eof102:
-		lex.cs = 102
-		goto _test_eof
 	_test_eof496:
 		lex.cs = 496
 		goto _test_eof
+	_test_eof102:
+		lex.cs = 102
+		goto _test_eof
 	_test_eof497:
 		lex.cs = 497
 		goto _test_eof
@@ -21584,21 +21632,21 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof503:
 		lex.cs = 503
 		goto _test_eof
+	_test_eof504:
+		lex.cs = 504
+		goto _test_eof
 	_test_eof103:
 		lex.cs = 103
 		goto _test_eof
 	_test_eof104:
 		lex.cs = 104
 		goto _test_eof
-	_test_eof504:
-		lex.cs = 504
+	_test_eof505:
+		lex.cs = 505
 		goto _test_eof
 	_test_eof105:
 		lex.cs = 105
 		goto _test_eof
-	_test_eof505:
-		lex.cs = 505
-		goto _test_eof
 	_test_eof506:
 		lex.cs = 506
 		goto _test_eof
@@ -21608,24 +21656,24 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof508:
 		lex.cs = 508
 		goto _test_eof
-	_test_eof106:
-		lex.cs = 106
-		goto _test_eof
 	_test_eof509:
 		lex.cs = 509
 		goto _test_eof
+	_test_eof106:
+		lex.cs = 106
+		goto _test_eof
 	_test_eof510:
 		lex.cs = 510
 		goto _test_eof
 	_test_eof511:
 		lex.cs = 511
 		goto _test_eof
-	_test_eof107:
-		lex.cs = 107
-		goto _test_eof
 	_test_eof512:
 		lex.cs = 512
 		goto _test_eof
+	_test_eof107:
+		lex.cs = 107
+		goto _test_eof
 	_test_eof513:
 		lex.cs = 513
 		goto _test_eof
@@ -21635,12 +21683,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof515:
 		lex.cs = 515
 		goto _test_eof
-	_test_eof108:
-		lex.cs = 108
-		goto _test_eof
 	_test_eof516:
 		lex.cs = 516
 		goto _test_eof
+	_test_eof108:
+		lex.cs = 108
+		goto _test_eof
 	_test_eof517:
 		lex.cs = 517
 		goto _test_eof
@@ -21650,12 +21698,12 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof519:
 		lex.cs = 519
 		goto _test_eof
-	_test_eof109:
-		lex.cs = 109
-		goto _test_eof
 	_test_eof520:
 		lex.cs = 520
 		goto _test_eof
+	_test_eof109:
+		lex.cs = 109
+		goto _test_eof
 	_test_eof521:
 		lex.cs = 521
 		goto _test_eof
@@ -21665,6 +21713,9 @@ func (lex *Lexer) Lex(lval Lval) int {
 	_test_eof523:
 		lex.cs = 523
 		goto _test_eof
+	_test_eof524:
+		lex.cs = 524
+		goto _test_eof
 
 	_test_eof:
 		{
@@ -21948,473 +21999,475 @@ func (lex *Lexer) Lex(lval Lval) int {
 			case 160:
 				goto tr294
 			case 161:
-				goto tr8
+				goto tr296
 			case 162:
-				goto tr294
+				goto tr8
 			case 163:
-				goto tr294
+				goto tr296
 			case 164:
-				goto tr294
+				goto tr296
 			case 165:
-				goto tr294
+				goto tr296
 			case 166:
-				goto tr294
+				goto tr296
 			case 167:
-				goto tr294
+				goto tr296
 			case 168:
-				goto tr294
+				goto tr296
 			case 169:
-				goto tr294
+				goto tr296
 			case 170:
-				goto tr294
+				goto tr296
 			case 171:
-				goto tr294
+				goto tr296
 			case 172:
-				goto tr294
+				goto tr296
+			case 173:
+				goto tr296
 			case 90:
 				goto tr124
 			case 91:
 				goto tr124
-			case 173:
-				goto tr294
 			case 174:
-				goto tr294
+				goto tr296
 			case 175:
-				goto tr294
+				goto tr296
 			case 176:
-				goto tr294
+				goto tr296
 			case 177:
-				goto tr294
+				goto tr296
 			case 178:
-				goto tr294
+				goto tr296
 			case 179:
-				goto tr294
+				goto tr296
 			case 180:
-				goto tr294
+				goto tr296
 			case 181:
-				goto tr294
+				goto tr296
 			case 182:
-				goto tr294
+				goto tr296
 			case 183:
-				goto tr294
+				goto tr296
 			case 184:
-				goto tr294
+				goto tr296
 			case 185:
-				goto tr294
+				goto tr296
 			case 186:
-				goto tr294
+				goto tr296
 			case 187:
-				goto tr294
+				goto tr296
 			case 188:
-				goto tr294
+				goto tr296
 			case 189:
-				goto tr294
+				goto tr296
 			case 190:
-				goto tr294
+				goto tr296
 			case 191:
-				goto tr294
+				goto tr296
 			case 192:
-				goto tr294
+				goto tr296
 			case 193:
-				goto tr294
+				goto tr296
 			case 194:
-				goto tr294
+				goto tr296
 			case 195:
-				goto tr294
+				goto tr296
 			case 196:
-				goto tr294
+				goto tr296
 			case 197:
-				goto tr294
+				goto tr296
 			case 198:
-				goto tr294
+				goto tr296
 			case 199:
-				goto tr294
+				goto tr296
 			case 200:
-				goto tr294
+				goto tr296
 			case 201:
-				goto tr294
+				goto tr296
 			case 202:
-				goto tr294
+				goto tr296
 			case 203:
-				goto tr294
+				goto tr296
 			case 204:
-				goto tr294
+				goto tr296
 			case 205:
-				goto tr294
+				goto tr296
 			case 206:
-				goto tr294
+				goto tr296
 			case 207:
-				goto tr294
+				goto tr296
 			case 208:
-				goto tr294
+				goto tr296
 			case 209:
-				goto tr294
+				goto tr296
 			case 210:
-				goto tr294
+				goto tr296
 			case 211:
-				goto tr294
+				goto tr296
 			case 212:
-				goto tr294
+				goto tr296
 			case 213:
-				goto tr294
+				goto tr296
 			case 214:
-				goto tr294
+				goto tr296
 			case 215:
-				goto tr294
+				goto tr296
 			case 216:
-				goto tr294
+				goto tr296
 			case 217:
-				goto tr294
+				goto tr296
 			case 218:
-				goto tr294
+				goto tr296
 			case 219:
-				goto tr294
+				goto tr296
 			case 220:
-				goto tr294
+				goto tr296
 			case 221:
-				goto tr374
+				goto tr296
 			case 222:
-				goto tr294
+				goto tr376
 			case 223:
-				goto tr294
+				goto tr296
 			case 224:
-				goto tr294
+				goto tr296
 			case 225:
-				goto tr294
+				goto tr296
 			case 226:
-				goto tr294
+				goto tr296
 			case 227:
-				goto tr294
+				goto tr296
 			case 228:
-				goto tr294
+				goto tr296
 			case 229:
-				goto tr294
+				goto tr296
 			case 230:
-				goto tr294
+				goto tr296
 			case 231:
-				goto tr294
+				goto tr296
 			case 232:
-				goto tr294
+				goto tr296
 			case 233:
-				goto tr294
+				goto tr296
 			case 234:
-				goto tr294
+				goto tr296
 			case 235:
-				goto tr294
+				goto tr296
 			case 236:
-				goto tr394
+				goto tr296
 			case 237:
-				goto tr294
+				goto tr396
 			case 238:
-				goto tr294
+				goto tr296
 			case 239:
-				goto tr294
+				goto tr296
 			case 240:
-				goto tr294
+				goto tr296
 			case 241:
-				goto tr294
+				goto tr296
 			case 242:
-				goto tr294
+				goto tr296
 			case 243:
-				goto tr294
+				goto tr296
 			case 244:
-				goto tr294
+				goto tr296
 			case 245:
-				goto tr294
+				goto tr296
 			case 246:
-				goto tr294
+				goto tr296
 			case 247:
-				goto tr294
+				goto tr296
 			case 248:
-				goto tr294
+				goto tr296
 			case 249:
-				goto tr294
+				goto tr296
 			case 250:
-				goto tr294
+				goto tr296
 			case 251:
-				goto tr294
+				goto tr296
 			case 252:
-				goto tr294
+				goto tr296
 			case 253:
-				goto tr294
+				goto tr296
 			case 254:
-				goto tr294
+				goto tr296
 			case 255:
-				goto tr294
+				goto tr296
 			case 256:
-				goto tr294
+				goto tr296
 			case 257:
-				goto tr294
+				goto tr296
 			case 258:
-				goto tr294
+				goto tr296
 			case 259:
-				goto tr294
+				goto tr296
 			case 260:
-				goto tr294
+				goto tr296
 			case 261:
-				goto tr294
+				goto tr296
 			case 262:
-				goto tr422
+				goto tr296
 			case 263:
-				goto tr294
+				goto tr425
 			case 264:
-				goto tr294
+				goto tr296
 			case 265:
-				goto tr426
+				goto tr296
 			case 266:
-				goto tr294
+				goto tr429
 			case 267:
-				goto tr294
+				goto tr296
 			case 268:
-				goto tr294
+				goto tr296
 			case 269:
-				goto tr294
+				goto tr296
 			case 270:
-				goto tr294
+				goto tr296
 			case 271:
-				goto tr294
+				goto tr296
 			case 272:
-				goto tr294
+				goto tr296
 			case 273:
-				goto tr294
+				goto tr296
 			case 274:
-				goto tr294
+				goto tr296
 			case 275:
-				goto tr294
+				goto tr296
 			case 276:
-				goto tr294
+				goto tr296
 			case 277:
-				goto tr294
+				goto tr296
 			case 278:
-				goto tr294
+				goto tr296
 			case 279:
-				goto tr294
+				goto tr296
 			case 280:
-				goto tr294
+				goto tr296
 			case 281:
-				goto tr294
+				goto tr296
 			case 282:
-				goto tr294
+				goto tr296
 			case 283:
-				goto tr294
+				goto tr296
 			case 284:
-				goto tr294
+				goto tr296
 			case 285:
-				goto tr294
+				goto tr296
 			case 286:
-				goto tr294
+				goto tr296
 			case 287:
-				goto tr294
+				goto tr296
 			case 288:
-				goto tr294
+				goto tr296
 			case 289:
-				goto tr294
+				goto tr296
 			case 290:
-				goto tr458
+				goto tr296
 			case 291:
-				goto tr294
+				goto tr461
 			case 292:
-				goto tr294
+				goto tr296
 			case 293:
-				goto tr294
+				goto tr296
 			case 294:
-				goto tr294
+				goto tr296
 			case 295:
-				goto tr294
+				goto tr296
 			case 296:
-				goto tr294
+				goto tr296
 			case 297:
-				goto tr294
+				goto tr296
 			case 298:
-				goto tr294
+				goto tr296
 			case 299:
-				goto tr294
+				goto tr296
 			case 300:
-				goto tr294
+				goto tr296
 			case 301:
-				goto tr294
+				goto tr296
 			case 302:
-				goto tr294
+				goto tr296
 			case 303:
-				goto tr294
+				goto tr296
 			case 304:
-				goto tr294
+				goto tr296
 			case 305:
-				goto tr294
+				goto tr296
 			case 306:
-				goto tr294
+				goto tr296
 			case 307:
-				goto tr294
+				goto tr296
 			case 308:
-				goto tr294
+				goto tr296
 			case 309:
-				goto tr294
+				goto tr296
 			case 310:
-				goto tr294
+				goto tr296
 			case 311:
-				goto tr294
+				goto tr296
 			case 312:
-				goto tr294
+				goto tr296
 			case 313:
-				goto tr294
+				goto tr296
 			case 314:
-				goto tr294
+				goto tr296
 			case 315:
-				goto tr294
+				goto tr296
 			case 316:
-				goto tr294
+				goto tr296
 			case 317:
-				goto tr294
+				goto tr296
 			case 318:
-				goto tr294
+				goto tr296
 			case 319:
-				goto tr294
+				goto tr296
 			case 320:
-				goto tr294
+				goto tr296
 			case 321:
-				goto tr294
+				goto tr296
 			case 322:
-				goto tr294
+				goto tr296
 			case 323:
-				goto tr294
+				goto tr296
 			case 324:
-				goto tr294
+				goto tr296
 			case 325:
-				goto tr294
+				goto tr296
 			case 326:
-				goto tr294
+				goto tr296
 			case 327:
-				goto tr294
+				goto tr296
 			case 328:
-				goto tr294
+				goto tr296
 			case 329:
-				goto tr294
+				goto tr296
 			case 330:
-				goto tr294
+				goto tr296
 			case 331:
-				goto tr294
+				goto tr296
 			case 332:
-				goto tr294
+				goto tr296
 			case 333:
-				goto tr294
+				goto tr296
 			case 334:
-				goto tr294
+				goto tr296
 			case 335:
-				goto tr294
+				goto tr296
 			case 336:
-				goto tr294
+				goto tr296
 			case 337:
-				goto tr294
+				goto tr296
 			case 338:
-				goto tr294
+				goto tr296
 			case 339:
-				goto tr294
+				goto tr296
 			case 340:
-				goto tr294
+				goto tr296
 			case 341:
-				goto tr294
+				goto tr296
 			case 342:
-				goto tr294
+				goto tr296
 			case 343:
-				goto tr294
+				goto tr296
 			case 344:
-				goto tr294
+				goto tr296
 			case 345:
-				goto tr294
+				goto tr296
 			case 346:
-				goto tr294
+				goto tr296
 			case 347:
-				goto tr294
+				goto tr296
 			case 348:
-				goto tr294
+				goto tr296
 			case 349:
-				goto tr294
+				goto tr296
 			case 350:
-				goto tr294
+				goto tr296
 			case 351:
-				goto tr526
+				goto tr296
 			case 352:
-				goto tr294
+				goto tr529
 			case 353:
-				goto tr294
+				goto tr296
 			case 354:
-				goto tr294
+				goto tr296
 			case 355:
-				goto tr294
+				goto tr296
 			case 356:
-				goto tr294
+				goto tr296
 			case 357:
-				goto tr294
+				goto tr296
 			case 358:
-				goto tr294
+				goto tr296
 			case 359:
-				goto tr294
+				goto tr296
 			case 360:
-				goto tr294
+				goto tr296
 			case 361:
-				goto tr294
+				goto tr296
 			case 362:
-				goto tr294
+				goto tr296
 			case 363:
-				goto tr294
+				goto tr296
 			case 364:
-				goto tr294
+				goto tr296
 			case 365:
-				goto tr294
+				goto tr296
 			case 366:
-				goto tr294
+				goto tr296
 			case 367:
-				goto tr294
+				goto tr296
 			case 368:
-				goto tr294
+				goto tr296
 			case 369:
-				goto tr294
+				goto tr296
 			case 370:
-				goto tr294
+				goto tr296
 			case 371:
-				goto tr294
+				goto tr296
 			case 372:
-				goto tr294
+				goto tr296
 			case 373:
-				goto tr294
+				goto tr296
 			case 374:
-				goto tr294
+				goto tr296
 			case 375:
-				goto tr294
+				goto tr296
 			case 376:
-				goto tr294
+				goto tr296
 			case 377:
-				goto tr294
+				goto tr296
 			case 378:
-				goto tr294
+				goto tr296
 			case 379:
-				goto tr294
+				goto tr296
 			case 380:
-				goto tr294
+				goto tr296
 			case 381:
-				goto tr294
+				goto tr296
 			case 382:
-				goto tr294
+				goto tr296
 			case 383:
-				goto tr294
+				goto tr296
 			case 384:
-				goto tr294
+				goto tr296
 			case 385:
-				goto tr294
+				goto tr296
 			case 386:
-				goto tr294
+				goto tr296
 			case 387:
-				goto tr294
+				goto tr296
 			case 388:
-				goto tr294
+				goto tr296
 			case 389:
-				goto tr294
+				goto tr296
 			case 390:
-				goto tr294
+				goto tr296
 			case 391:
-				goto tr294
+				goto tr296
 			case 392:
-				goto tr572
+				goto tr296
+			case 393:
+				goto tr575
 			case 92:
 				goto tr126
 			case 93:
@@ -22427,260 +22480,260 @@ func (lex *Lexer) Lex(lval Lval) int {
 				goto tr126
 			case 97:
 				goto tr126
-			case 393:
-				goto tr294
 			case 394:
-				goto tr294
+				goto tr296
 			case 395:
-				goto tr294
+				goto tr296
 			case 396:
-				goto tr232
+				goto tr296
 			case 397:
-				goto tr294
-			case 398:
-				goto tr294
-			case 399:
-				goto tr294
-			case 400:
-				goto tr294
-			case 401:
-				goto tr294
-			case 402:
-				goto tr294
-			case 403:
-				goto tr294
-			case 404:
-				goto tr294
-			case 405:
-				goto tr294
-			case 406:
-				goto tr294
-			case 407:
-				goto tr294
-			case 408:
-				goto tr294
-			case 409:
-				goto tr294
-			case 410:
-				goto tr294
-			case 411:
-				goto tr294
-			case 412:
-				goto tr294
-			case 413:
-				goto tr294
-			case 414:
-				goto tr294
-			case 415:
-				goto tr294
-			case 416:
-				goto tr294
-			case 417:
-				goto tr294
-			case 418:
-				goto tr294
-			case 419:
-				goto tr294
-			case 420:
-				goto tr294
-			case 421:
-				goto tr294
-			case 422:
-				goto tr294
-			case 423:
-				goto tr294
-			case 424:
-				goto tr294
-			case 425:
-				goto tr294
-			case 426:
-				goto tr294
-			case 427:
-				goto tr294
-			case 428:
-				goto tr294
-			case 429:
-				goto tr294
-			case 430:
-				goto tr294
-			case 431:
-				goto tr294
-			case 432:
-				goto tr294
-			case 433:
-				goto tr294
-			case 434:
-				goto tr294
-			case 435:
-				goto tr294
-			case 436:
-				goto tr294
-			case 437:
-				goto tr294
-			case 438:
-				goto tr294
-			case 439:
-				goto tr294
-			case 440:
-				goto tr294
-			case 441:
-				goto tr294
-			case 442:
-				goto tr294
-			case 443:
-				goto tr294
-			case 444:
-				goto tr294
-			case 445:
-				goto tr294
-			case 446:
-				goto tr294
-			case 447:
-				goto tr294
-			case 448:
-				goto tr294
-			case 449:
-				goto tr294
-			case 450:
-				goto tr294
-			case 451:
-				goto tr294
-			case 452:
-				goto tr294
-			case 453:
-				goto tr294
-			case 454:
-				goto tr294
-			case 455:
-				goto tr294
-			case 456:
-				goto tr294
-			case 457:
-				goto tr294
-			case 458:
-				goto tr294
-			case 459:
-				goto tr294
-			case 460:
-				goto tr294
-			case 461:
-				goto tr294
-			case 462:
 				goto tr232
-			case 464:
-				goto tr658
+			case 398:
+				goto tr296
+			case 399:
+				goto tr296
+			case 400:
+				goto tr296
+			case 401:
+				goto tr296
+			case 402:
+				goto tr296
+			case 403:
+				goto tr296
+			case 404:
+				goto tr296
+			case 405:
+				goto tr296
+			case 406:
+				goto tr296
+			case 407:
+				goto tr296
+			case 408:
+				goto tr296
+			case 409:
+				goto tr296
+			case 410:
+				goto tr296
+			case 411:
+				goto tr296
+			case 412:
+				goto tr296
+			case 413:
+				goto tr296
+			case 414:
+				goto tr296
+			case 415:
+				goto tr296
+			case 416:
+				goto tr296
+			case 417:
+				goto tr296
+			case 418:
+				goto tr296
+			case 419:
+				goto tr296
+			case 420:
+				goto tr296
+			case 421:
+				goto tr296
+			case 422:
+				goto tr296
+			case 423:
+				goto tr296
+			case 424:
+				goto tr296
+			case 425:
+				goto tr296
+			case 426:
+				goto tr296
+			case 427:
+				goto tr296
+			case 428:
+				goto tr296
+			case 429:
+				goto tr296
+			case 430:
+				goto tr296
+			case 431:
+				goto tr296
+			case 432:
+				goto tr296
+			case 433:
+				goto tr296
+			case 434:
+				goto tr296
+			case 435:
+				goto tr296
+			case 436:
+				goto tr296
+			case 437:
+				goto tr296
+			case 438:
+				goto tr296
+			case 439:
+				goto tr296
+			case 440:
+				goto tr296
+			case 441:
+				goto tr296
+			case 442:
+				goto tr296
+			case 443:
+				goto tr296
+			case 444:
+				goto tr296
+			case 445:
+				goto tr296
+			case 446:
+				goto tr296
+			case 447:
+				goto tr296
+			case 448:
+				goto tr296
+			case 449:
+				goto tr296
+			case 450:
+				goto tr296
+			case 451:
+				goto tr296
+			case 452:
+				goto tr296
+			case 453:
+				goto tr296
+			case 454:
+				goto tr296
+			case 455:
+				goto tr296
+			case 456:
+				goto tr296
+			case 457:
+				goto tr296
+			case 458:
+				goto tr296
+			case 459:
+				goto tr296
+			case 460:
+				goto tr296
+			case 461:
+				goto tr296
+			case 462:
+				goto tr296
+			case 463:
+				goto tr232
 			case 465:
-				goto tr660
+				goto tr661
+			case 466:
+				goto tr663
 			case 98:
 				goto tr138
-			case 466:
-				goto tr664
 			case 467:
-				goto tr664
+				goto tr667
 			case 468:
-				goto tr666
-			case 470:
+				goto tr667
+			case 469:
 				goto tr669
 			case 471:
-				goto tr670
-			case 473:
-				goto tr679
+				goto tr672
+			case 472:
+				goto tr673
 			case 474:
-				goto tr681
-			case 475:
 				goto tr682
+			case 475:
+				goto tr684
 			case 476:
-				goto tr679
+				goto tr685
 			case 477:
-				goto tr686
-			case 479:
-				goto tr696
+				goto tr682
+			case 478:
+				goto tr689
 			case 480:
-				goto tr698
-			case 481:
 				goto tr699
+			case 481:
+				goto tr701
 			case 482:
-				goto tr696
+				goto tr702
 			case 483:
-				goto tr703
-			case 485:
-				goto tr713
+				goto tr699
+			case 484:
+				goto tr706
 			case 486:
-				goto tr715
-			case 487:
 				goto tr716
+			case 487:
+				goto tr718
 			case 488:
-				goto tr713
+				goto tr719
 			case 489:
-				goto tr720
-			case 491:
+				goto tr716
+			case 490:
 				goto tr723
-			case 493:
-				goto tr729
+			case 492:
+				goto tr726
 			case 494:
-				goto tr731
+				goto tr732
 			case 495:
-				goto tr729
+				goto tr734
+			case 496:
+				goto tr732
 			case 102:
 				goto tr144
-			case 496:
-				goto tr733
-			case 498:
-				goto tr743
+			case 497:
+				goto tr736
 			case 499:
-				goto tr744
+				goto tr746
 			case 500:
-				goto tr745
-			case 501:
 				goto tr747
+			case 501:
+				goto tr748
 			case 502:
-				goto tr748
+				goto tr750
 			case 503:
-				goto tr748
+				goto tr751
+			case 504:
+				goto tr751
 			case 103:
 				goto tr146
 			case 104:
 				goto tr146
-			case 504:
-				goto tr748
+			case 505:
+				goto tr751
 			case 105:
 				goto tr146
-			case 505:
-				goto tr748
 			case 506:
-				goto tr752
-			case 508:
+				goto tr751
+			case 507:
 				goto tr755
+			case 509:
+				goto tr758
 			case 106:
 				goto tr150
-			case 510:
-				goto tr760
 			case 511:
-				goto tr762
+				goto tr763
+			case 512:
+				goto tr765
 			case 107:
 				goto tr153
-			case 512:
-				goto tr766
-			case 514:
-				goto tr771
+			case 513:
+				goto tr769
 			case 515:
-				goto tr773
+				goto tr774
+			case 516:
+				goto tr776
 			case 108:
 				goto tr155
-			case 516:
-				goto tr777
-			case 518:
-				goto tr782
+			case 517:
+				goto tr780
 			case 519:
-				goto tr784
+				goto tr785
+			case 520:
+				goto tr787
 			case 109:
 				goto tr157
-			case 520:
-				goto tr788
-			case 522:
+			case 521:
 				goto tr791
 			case 523:
-				goto tr792
+				goto tr794
+			case 524:
+				goto tr795
 			}
 		}
 
@@ -22689,7 +22742,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 		}
 	}
 
-//line scanner/scanner.rl:496
+//line scanner/scanner.rl:498
 
 	token.FreeFloating = lex.FreeFloating
 	token.Value = string(lex.data[lex.ts:lex.te])
diff --git a/scanner/scanner.rl b/scanner/scanner.rl
index 0747401..67738aa 100644
--- a/scanner/scanner.rl
+++ b/scanner/scanner.rl
@@ -231,6 +231,7 @@ func (lex *Lexer) Lex(lval Lval) int {
             'for'i                            => {lex.setTokenPosition(token); tok = T_FOR; fbreak;};
             'foreach'i                        => {lex.setTokenPosition(token); tok = T_FOREACH; fbreak;};
             'function'i | 'cfunction'i        => {lex.setTokenPosition(token); tok = T_FUNCTION; fbreak;};
+            'fn'i                             => {lex.setTokenPosition(token); tok = T_FN; fbreak;};
             'global'i                         => {lex.setTokenPosition(token); tok = T_GLOBAL; fbreak;};
             'goto'i                           => {lex.setTokenPosition(token); tok = T_GOTO; fbreak;};
             'if'i                             => {lex.setTokenPosition(token); tok = T_IF; fbreak;};
@@ -305,6 +306,7 @@ func (lex *Lexer) Lex(lval Lval) int {
             '<<'                              => {lex.setTokenPosition(token); tok = T_SL; fbreak;};
             '>>'                              => {lex.setTokenPosition(token); tok = T_SR; fbreak;};
             '??'                              => {lex.setTokenPosition(token); tok = T_COALESCE; fbreak;};
+            '??='                             => {lex.setTokenPosition(token); tok = T_COALESCE_EQUAL; fbreak;};
 
             '(' whitespace* 'array'i whitespace* ')'                     => {lex.setTokenPosition(token); tok = T_ARRAY_CAST; fbreak;};
             '(' whitespace* ('bool'i|'boolean'i) whitespace* ')'         => {lex.setTokenPosition(token); tok = T_BOOL_CAST; fbreak;};